From b31e63468fa7607335d06ed5f8ac910ea31eea47 Mon Sep 17 00:00:00 2001 From: aboyko Date: Fri, 1 Nov 2024 11:20:42 -0400 Subject: [PATCH] Replace PostgreSQL grammar to support COLLATE --- .../commons/jpql/grammars/PostgreSqlLexer.g4 | 2562 +- .../commons/jpql/grammars/PostgreSqlParser.g4 | 6779 +- .../LexerDispatchingErrorListener.java | 76 + .../ParserDispatchingErrorListener.java | 76 + .../parser/postgresql/PostgreSqlLexer.java | 10775 +- .../postgresql/PostgreSqlLexerBase.java | 82 + .../parser/postgresql/PostgreSqlParser.java | 154677 ++++++++++----- .../postgresql/PostgreSqlParserBase.java | 123 + .../PostgreSqlParserBaseListener.java | 7714 +- .../postgresql/PostgreSqlParserListener.java | 7656 +- .../jpa/queries/PostgreSqlSemanticTokens.java | 65 +- .../queries/PostgreSqlSemanticTokensTest.java | 42 +- .../data/jpa/queries/QueryReconcilerTest.java | 2 +- 13 files changed, 130141 insertions(+), 60488 deletions(-) create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/LexerDispatchingErrorListener.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/ParserDispatchingErrorListener.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexerBase.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBase.java diff --git a/headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 b/headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 index 90135f8c0..a2928909f 100644 --- a/headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 +++ b/headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 @@ -1,937 +1,1681 @@ -// The MIT License +/* +based on +https://github.com/tunnelvisionlabs/antlr4-grammar-postgresql/blob/master/src/com/tunnelvisionlabs/postgresql/PostgreSqlLexer.g4 +*/ -// Copyright 2018 Tal Shprecher +/* + * [The "MIT license"] + * Copyright (C) 2014 Sam Harwell, Tunnel Vision Laboratories, LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * 1. The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * 2. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * 3. Except as contained in this notice, the name of Tunnel Vision + * Laboratories, LLC. shall not be used in advertising or otherwise to + * promote the sale, use or other dealings in this Software without prior + * written authorization from Tunnel Vision Laboratories, LLC. + */ -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: - -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. - -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. +// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine +// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true lexer grammar PostgreSqlLexer; +/* Reference: + * http://www.postgresql.org/docs/9.3/static/sql-syntax-lexical.html + */ -// Skip -WHITESPACE : [ \t\r\n]+ -> skip; -BLOCK_COMMENT : '/*' .*? '*/' -> channel(HIDDEN); -LINE_COMMENT : '--' .*? '\n' -> channel(HIDDEN); +options { + superClass = PostgreSqlLexerBase; + caseInsensitive = true; +} -// Fragments -fragment A : ('A'|'a') ; -fragment B : ('B'|'b') ; -fragment C : ('C'|'c') ; -fragment D : ('D'|'d') ; -fragment E : ('E'|'e') ; -fragment F : ('F'|'f') ; -fragment G : ('G'|'g') ; -fragment H : ('H'|'h') ; -fragment I : ('I'|'i') ; -fragment J : ('J'|'j') ; -fragment K : ('K'|'k') ; -fragment L : ('L'|'l') ; -fragment M : ('M'|'m') ; -fragment N : ('N'|'n') ; -fragment O : ('O'|'o') ; -fragment P : ('P'|'p') ; -fragment Q : ('Q'|'q') ; -fragment R : ('R'|'r') ; -fragment S : ('S'|'s') ; -fragment T : ('T'|'t') ; -fragment U : ('U'|'u') ; -fragment V : ('V'|'v') ; -fragment W : ('W'|'w') ; -fragment X : ('X'|'x') ; -fragment Y : ('Y'|'y') ; -fragment Z : ('Z'|'z') ; +@header { +} +@members { +/* This field stores the tags which are used to detect the end of a dollar-quoted string literal. + */ +} +// -fragment HEX_DIGIT : [0-9A-F]; -fragment DEC_DIGIT : [0-9]; -fragment DQUOTA_STRING : '"' ( '\\'. | '""' | ~('"' | '\\') )* '"'; -fragment SQUOTA_STRING : '\'' ('\\'. | '\'\'' | ~('\'' | '\\'))* '\''; -fragment BQUOTA_STRING : '`' ( '\\'. | '``' | ~('`' | '\\'))* '`'; +SPEL: '#{' ANYTHING '}'; +fragment ANYTHING: (.)*?; -// Keywords -A_ : A; -ABORT : A B O R T; -ABS : A B S; -ABSOLUTE : A B S O L U T E; -ACCESS : A C C E S S; -ACTION : A C T I O N; -ADA : A D A; -ADD : A D D; -ADMIN : A D M I N; -AFTER : A F T E R; -AGGREGATE : A G G R E G A T E; -ALIAS : A L I A S; -ALL : A L L; -ALLOCATE : A L L O C A T E; -ALSO : A L S O; -ALTER : A L T E R; -ALWAYS : A L W A Y S; -ANALYSE : A N A L Y S E; -ANALYZE : A N A L Y Z E; -AND : A N D; -ANY : A N Y; -ARE : A R E; -ARRAY : A R R A Y; -AS : A S; -ASC : A S C; -ASENSITIVE : A S E N S I T I V E; -ASSERTION : A S S E R T I O N; -ASSIGNMENT : A S S I G N M E N T; -ASYMMETRIC : A S Y M M E T R I C; -AT : A T; -ATOMIC : A T O M I C; -ATTRIBUTE : A T T R I B U T E; -ATTRIBUTES : A T T R I B U T E S; -AUTHORIZATION : A U T H O R I Z A T I O N; -AVG : A V G; -BACKWARD : B A C K W A R D; -BEFORE : B E F O R E; -BEGIN : B E G I N; -BERNOULLI : B E R N O U L L I; -BETWEEN : B E T W E E N; -BIGINT : B I G I N T; -BINARY : B I N A R Y; -BIT : B I T; -BIT_LENGTH : B I T '_' L E N G T H; -BITVAR : B I T V A R; -BLOB : B L O B; -BOOLEAN : B O O L E A N; -BOTH : B O T H; -BREADTH : B R E A D T H; -BUFFERS : B U F F E R S; -BY : B Y; -C_ : C; -CACHE : C A C H E; -CALL : C A L L; -CALLED : C A L L E D; -CARDINALITY : C A R D I N A L I T Y; -CASCADE : C A S C A D E; -CASCADED : C A S C A D E D; -CASE : C A S E; -CAST : C A S T; -CATALOG : C A T A L O G; -CATALOG_NAME : C A T A L O G '_' N A M E; -CEIL : C E I L; -CEILING : C E I L I N G; -CHAIN : C H A I N; -CHAR : C H A R; -CHAR_LENGTH : C H A R '_' L E N G T H; -CHARACTER : C H A R A C T E R; -CHARACTER_LENGTH : C H A R A C T E R '_' L E N G T H; -CHARACTER_SET_CATALOG : C H A R A C T E R '_' S E T '_' C A T A L O G; -CHARACTER_SET_NAME : C H A R A C T E R '_' S E T '_' N A M E; -CHARACTER_SET_SCHEMA : C H A R A C T E R '_' S E T '_' S C H E M A; -CHARACTERISTICS : C H A R A C T E R I S T I C S; -CHARACTERS : C H A R A C T E R S; -CHECK : C H E C K; -CHECKED : C H E C K E D; -CHECKPOINT : C H E C K P O I N T; -CLASS : C L A S S; -CLASS_ORIGIN : C L A S S '_' O R I G I N; -CLOB : C L O B; -CLOSE : C L O S E; -CLUSTER : C L U S T E R; -COALESCE : C O A L E S C E; -COBOL : C O B O L; -COLLATE : C O L L A T E; -COLLATION : C O L L A T I O N; -COLLATION_CATALOG : C O L L A T I O N '_' C A T A L O G; -COLLATION_NAME : C O L L A T I O N '_' N A M E; -COLLATION_SCHEMA : C O L L A T I O N '_' S C H E M A; -COLLECT : C O L L E C T; -COLUMN : C O L U M N; -COLUMN_NAME : C O L U M N '_' N A M E; -COMMAND_FUNCTION : C O M M A N D '_' F U N C T I O N; -COMMAND_FUNCTION_CODE : C O M M A N D '_' F U N C T I O N '_' C O D E; -COMMENT : C O M M E N T; -COMMIT : C O M M I T; -COMMITTED : C O M M I T T E D; -COMPLETION : C O M P L E T I O N; -CONDITION : C O N D I T I O N; -CONDITION_NUMBER : C O N D I T I O N '_' N U M B E R; -CONFIGURATION : C O N F I G U R A T I O N; -CONFLICT : C O N F L I C T; -CONNECT : C O N N E C T; -CONNECTION : C O N N E C T I O N; -CONNECTION_NAME : C O N N E C T I O N '_' N A M E; -CONSTRAINT : C O N S T R A I N T; -CONSTRAINT_CATALOG : C O N S T R A I N T '_' C A T A L O G; -CONSTRAINT_NAME : C O N S T R A I N T '_' N A M E; -CONSTRAINT_SCHEMA : C O N S T R A I N T '_' S C H E M A; -CONSTRAINTS : C O N S T R A I N T S; -CONSTRUCTOR : C O N S T R U C T O R; -CONTAINS : C O N T A I N S; -CONTINUE : C O N T I N U E; -CONVERSION : C O N V E R S I O N; -CONVERT : C O N V E R T; -COPY : C O P Y; -CORR : C O R R; -CORRESPONDING : C O R R E S P O N D I N G; -COSTS : C O S T S; -COUNT : C O U N T; -COVAR_POP : C O V A R '_' P O P; -COVAR_SAMP : C O V A R '_' S A M P; -CREATE : C R E A T E; -CREATEDB : C R E A T E D B; -CREATEUSER : C R E A T E U S E R; -CROSS : C R O S S; -CSV : C S V; -CUBE : C U B E; -CUME_DIST : C U M E '_' D I S T; -CURRENT : C U R R E N T; -CURRENT_DATE : C U R R E N T '_' D A T E; -CURRENT_DEFAULT_TRANSFORM_GROUP : C U R R E N T '_' D E F A U L T '_' T R A N S F O R M '_' G R O U P; -CURRENT_PATH : C U R R E N T '_' P A T H; -CURRENT_ROLE : C U R R E N T '_' R O L E; -CURRENT_TIME : C U R R E N T '_' T I M E; -CURRENT_TIMESTAMP : C U R R E N T '_' T I M E S T A M P; -CURRENT_TRANSFORM_GROUP_FOR_TYPE : C U R R E N T '_' T R A N S F O R M '_' G R O U P '_' F O R '_' T Y P E; -CURRENT_USER : C U R R E N T '_' U S E R; -CURSOR : C U R S O R; -CURSOR_NAME : C U R S O R '_' N A M E; -CYCLE : C Y C L E; -DATA : D A T A; -DATABASE : D A T A B A S E; -DATE : D A T E; -DATETIME_INTERVAL_CODE : D A T E T I M E '_' I N T E R V A L '_' C O D E; -DATETIME_INTERVAL_PRECISION : D A T E T I M E '_' I N T E R V A L '_' P R E C I S I O N; -DAY : D A Y; -DEALLOCATE : D E A L L O C A T E; -DEC : D E C; -DECIMAL : D E C I M A L; -DECLARE : D E C L A R E; -DEFAULT : D E F A U L T; -DEFAULTS : D E F A U L T S; -DEFERABLE : D E F E R A B L E; -DEFERRABLE : D E F E R R A B L E; -DEFERRED : D E F E R R E D; -DEFINED : D E F I N E D; -DEFINER : D E F I N E R; -DEGREE : D E G R E E; -DELETE : D E L E T E; -DELIMITER : D E L I M I T E R; -DELIMITERS : D E L I M I T E R S; -DENSE_RANK : D E N S E '_' R A N K; -DEPENDS : D E P E N D S; -DEPTH : D E P T H; -DEREF : D E R E F; -DERIVED : D E R I V E D; -DESC : D E S C; -DESCRIBE : D E S C R I B E; -DESCRIPTOR : D E S C R I P T O R; -DESTROY : D E S T R O Y; -DESTRUCTOR : D E S T R U C T O R; -DETERMINISTIC : D E T E R M I N I S T I C; -DIAGNOSTICS : D I A G N O S T I C S; -DICTIONARY : D I C T I O N A R Y; -DISABLE : D I S A B L E; -DISABLE_PAGE_SKIPPING : D I S A B L E '_' P A G E '_' S K I P P I N G; -DISCARD : D I S C A R D; -DISCONNECT : D I S C O N N E C T; -DISPATCH : D I S P A T C H; -DISTINCT : D I S T I N C T; -DO : D O; -DOMAIN : D O M A I N; -DOUBLE : D O U B L E; -DROP : D R O P; -DYNAMIC : D Y N A M I C; -DYNAMIC_FUNCTION : D Y N A M I C '_' F U N C T I O N; -DYNAMIC_FUNCTION_CODE : D Y N A M I C '_' F U N C T I O N '_' C O D E; -EACH : E A C H; -ELEMENT : E L E M E N T; -ELSE : E L S E; -ENABLE : E N A B L E; -ENCODING : E N C O D I N G; -ENCRYPTED : E N C R Y P T E D; -END : E N D; -END_EXEC : E N D '-' E X E C; -EQUALS : E Q U A L S; -ESCAPE : E S C A P E; -EVERY : E V E R Y; -EXCEPT : E X C E P T; -EXCEPTION : E X C E P T I O N; -EXCLUDE : E X C L U D E; -EXCLUDING : E X C L U D I N G; -EXCLUSIVE : E X C L U S I V E; -EXEC : E X E C; -EXECUTE : E X E C U T E; -EXISTING : E X I S T I N G; -EXISTS : E X I S T S; -EXP : E X P; -EXPLAIN : E X P L A I N; -EXTENDED : E X T E N D E D; -EXTENSION : E X T E N S I O N; -EXTERNAL : E X T E R N A L; -EXTRACT : E X T R A C T; -FALSE : F A L S E; -FETCH : F E T C H; -FIELDS : F I E L D S; -FILTER : F I L T E R; -FINAL : F I N A L; -FIRST : F I R S T; -FLOAT : F L O A T; -FLOOR : F L O O R; -FOLLOWING : F O L L O W I N G; -FOR : F O R; -FORCE : F O R C E; -FOREIGN : F O R E I G N; -FORMAT : F O R M A T; -FORTRAN : F O R T R A N; -FORWARD : F O R W A R D; -FOUND : F O U N D; -FREE : F R E E; -FREEZE : F R E E Z E; -FROM : F R O M; -FULL : F U L L; -FUNCTION : F U N C T I O N; -FUSION : F U S I O N; -G_ : G; -GENERAL : G E N E R A L; -GENERATED : G E N E R A T E D; -GET : G E T; -GLOBAL : G L O B A L; -GO : G O; -GOTO : G O T O; -GRANT : G R A N T; -GRANTED : G R A N T E D; -GREATEST : G R E A T E S T; -GROUP : G R O U P; -GROUPING : G R O U P I N G; -HANDLER : H A N D L E R; -HAVING : H A V I N G; -HIERARCHY : H I E R A R C H Y; -HOLD : H O L D; -HOST : H O S T; -HOUR : H O U R; -IDENTITY : I D E N T I T Y; -IGNORE : I G N O R E; -ILIKE : I L I K E; -IMMEDIATE : I M M E D I A T E; -IMMUTABLE : I M M U T A B L E; -IMPLEMENTATION : I M P L E M E N T A T I O N; -IMPLICIT : I M P L I C I T; -IN : I N; -INCLUDING : I N C L U D I N G; -INCREMENT : I N C R E M E N T; -INDEX : I N D E X; -INDICATOR : I N D I C A T O R; -INFIX : I N F I X; -INHERITS : I N H E R I T S; -INITIALIZE : I N I T I A L I Z E; -INITIALLY : I N I T I A L L Y; -INNER : I N N E R; -INOUT : I N O U T; -INPUT : I N P U T; -INSENSITIVE : I N S E N S I T I V E; -INSERT : I N S E R T; -INSTANCE : I N S T A N C E; -INSTANTIABLE : I N S T A N T I A B L E; -INSTEAD : I N S T E A D; -INT : I N T; -INTEGER : I N T E G E R; -INTERSECT : I N T E R S E C T; -INTERSECTION : I N T E R S E C T I O N; -INTERVAL : I N T E R V A L; -INTO : I N T O; -INVOKER : I N V O K E R; -IS : I S; -ISOLATION : I S O L A T I O N; -ITERATE : I T E R A T E; -JOIN : J O I N; -K_ : K; -KEY : K E Y; -KEY_MEMBER : K E Y '_' M E M B E R; -KEY_TYPE : K E Y '_' T Y P E; -LABEL : L A B E L; -LANCOMPILER : L A N C O M P I L E R; -LANGUAGE : L A N G U A G E; -LARGE : L A R G E; -LAST : L A S T; -LATERAL : L A T E R A L; -LEADING : L E A D I N G; -LEAST : L E A S T; -LEFT : L E F T; -LENGTH : L E N G T H; -LESS : L E S S; -LEVEL : L E V E L; -LIKE : L I K E; -LIMIT : L I M I T; -LISTEN : L I S T E N; -LN : L N; -LOAD : L O A D; -LOCAL : L O C A L; -LOCALTIME : L O C A L T I M E; -LOCALTIMESTAMP : L O C A L T I M E S T A M P; -LOCATION : L O C A T I O N; -LOCATOR : L O C A T O R; -LOCK : L O C K; -LOCKED : L O C K E D; // TODO: added manually, fix in docs -LOWER : L O W E R; -M_ : M; -MAIN : M A I N; -MAP : M A P; -MAPPING : M A P P I N G; -MATCH : M A T C H; -MATCH_SIMPLE : M A T C H '_' S I M P L E; -MATCHED : M A T C H E D; -MAX : M A X; -MAXVALUE : M A X V A L U E; -MEMBER : M E M B E R; -MERGE : M E R G E; -MESSAGE_LENGTH : M E S S A G E '_' L E N G T H; -MESSAGE_OCTET_LENGTH : M E S S A G E '_' O C T E T '_' L E N G T H; -MESSAGE_TEXT : M E S S A G E '_' T E X T; -METHOD : M E T H O D; -MIN : M I N; -MINUTE : M I N U T E; -MINVALUE : M I N V A L U E; -MOD : M O D; -MODE : M O D E; -MODIFIES : M O D I F I E S; -MODIFY : M O D I F Y; -MODULE : M O D U L E; -MONTH : M O N T H; -MORE_ : M O R E; -MOVE : M O V E; -MULTISET : M U L T I S E T; -MUMPS : M U M P S; -NAME : N A M E; -NAMES : N A M E S; -NATIONAL : N A T I O N A L; -NATURAL : N A T U R A L; -NCHAR : N C H A R; -NCLOB : N C L O B; -NESTING : N E S T I N G; -NEW : N E W; -NEXT : N E X T; -NO : N O; -NOCREATEDB : N O C R E A T E D B; -NOCREATEUSER : N O C R E A T E U S E R; -NONE : N O N E; -NORMALIZE : N O R M A L I Z E; -NORMALIZED : N O R M A L I Z E D; -NOT : N O T; -NOTHING : N O T H I N G; -NOTIFY : N O T I F Y; -NOTNULL : N O T N U L L; -NOWAIT : N O W A I T; -NULL : N U L L; -NULLABLE : N U L L A B L E; -NULLIF : N U L L I F; -NULLS : N U L L S; -NUMBER : N U M B E R; -NUMERIC : N U M E R I C; -OBJECT : O B J E C T; -OCTET_LENGTH : O C T E T '_' L E N G T H; -OCTETS : O C T E T S; -OF : O F; -OFF : O F F; -OFFSET : O F F S E T; -OIDS : O I D S; -OLD : O L D; -ON : O N; -ONLY : O N L Y; -OPEN : O P E N; -OPERATION : O P E R A T I O N; -OPERATOR : O P E R A T O R; -OPTION : O P T I O N; -OPTIONS : O P T I O N S; -OR : O R; -ORDER : O R D E R; -ORDERING : O R D E R I N G; -ORDINALITY : O R D I N A L I T Y; -OTHERS : O T H E R S; -OUT : O U T; -OUTER : O U T E R; -OUTPUT : O U T P U T; -OVER : O V E R; -OVERLAPS : O V E R L A P S; -OVERLAY : O V E R L A Y; -OVERRIDING : O V E R R I D I N G; -OWNER : O W N E R; -PAD : P A D; -PARAMETER : P A R A M E T E R; -PARAMETER_MODE : P A R A M E T E R '_' M O D E; -PARAMETER_NAME : P A R A M E T E R '_' N A M E; -PARAMETER_ORDINAL_POSITION : P A R A M E T E R '_' O R D I N A L '_' P O S I T I O N; -PARAMETER_SPECIFIC_CATALOG : P A R A M E T E R '_' S P E C I F I C '_' C A T A L O G; -PARAMETER_SPECIFIC_NAME : P A R A M E T E R '_' S P E C I F I C '_' N A M E; -PARAMETER_SPECIFIC_SCHEMA : P A R A M E T E R '_' S P E C I F I C '_' S C H E M A; -PARAMETERS : P A R A M E T E R S; -PARSER : P A R S E R; -PARTIAL : P A R T I A L; -PARTITION : P A R T I T I O N; -PASCAL : P A S C A L; -PASSWORD : P A S S W O R D; -PATH : P A T H; -PERCENT_RANK : P E R C E N T '_' R A N K; -PERCENTILE_CONT : P E R C E N T I L E '_' C O N T; -PERCENTILE_DISC : P E R C E N T I L E '_' D I S C; -PLACING : P L A C I N G; -PLAIN : P L A I N; -PLANS : P L A N S; -PLI : P L I; -POSITION : P O S I T I O N; -POSTFIX : P O S T F I X; -POWER : P O W E R; -PRECEDING : P R E C E D I N G; -PRECISION : P R E C I S I O N; -PREFIX : P R E F I X; -PREORDER : P R E O R D E R; -PREPARE : P R E P A R E; -PREPARED : P R E P A R E D; -PRESERVE : P R E S E R V E; -PRIMARY : P R I M A R Y; -PRIOR : P R I O R; -PRIVILEGES : P R I V I L E G E S; -PROCEDURAL : P R O C E D U R A L; -PROCEDURE : P R O C E D U R E; -PUBLIC : P U B L I C; -PUBLICATION : P U B L I C A T I O N; -QUOTE : Q U O T E; -RANGE : R A N G E; -RANK : R A N K; -READ : R E A D; -READS : R E A D S; -REAL : R E A L; -REASSIGN : R E A S S I G N; -RECHECK : R E C H E C K; -RECURSIVE : R E C U R S I V E; -REF : R E F; -REFERENCES : R E F E R E N C E S; -REFERENCING : R E F E R E N C I N G; -REFRESH : R E F R E S H; -REGR_AVGX : R E G R '_' A V G X; -REGR_AVGY : R E G R '_' A V G Y; -REGR_COUNT : R E G R '_' C O U N T; -REGR_INTERCEPT : R E G R '_' I N T E R C E P T; -REGR_R2 : R E G R '_' R '2'; -REGR_SLOPE : R E G R '_' S L O P E; -REGR_SXX : R E G R '_' S X X; -REGR_SXY : R E G R '_' S X Y; -REGR_SYY : R E G R '_' S Y Y; -REINDEX : R E I N D E X; -RELATIVE : R E L A T I V E; -RELEASE : R E L E A S E; -RENAME : R E N A M E; -REPEATABLE : R E P E A T A B L E; -REPLACE : R E P L A C E; -REPLICA : R E P L I C A; -RESET : R E S E T; -RESTART : R E S T A R T; -RESTRICT : R E S T R I C T; -RESULT : R E S U L T; -RETURN : R E T U R N; -RETURNED_CARDINALITY : R E T U R N E D '_' C A R D I N A L I T Y; -RETURNED_LENGTH : R E T U R N E D '_' L E N G T H; -RETURNED_OCTET_LENGTH : R E T U R N E D '_' O C T E T '_' L E N G T H; -RETURNED_SQLSTATE : R E T U R N E D '_' S Q L S T A T E; -RETURNING : R E T U R N I N G; -RETURNS : R E T U R N S; -REVOKE : R E V O K E; -RIGHT : R I G H T; -ROLE : R O L E; -ROLLBACK : R O L L B A C K; -ROLLUP : R O L L U P; -ROUTINE : R O U T I N E; -ROUTINE_CATALOG : R O U T I N E '_' C A T A L O G; -ROUTINE_NAME : R O U T I N E '_' N A M E; -ROUTINE_SCHEMA : R O U T I N E '_' S C H E M A; -ROW : R O W; -ROW_COUNT : R O W '_' C O U N T; -ROW_NUMBER : R O W '_' N U M B E R; -ROWS : R O W S; -RULE : R U L E; -SAVEPOINT : S A V E P O I N T; -SCALE : S C A L E; -SCHEMA : S C H E M A; -SCHEMA_NAME : S C H E M A '_' N A M E; -SCOPE : S C O P E; -SCOPE_CATALOG : S C O P E '_' C A T A L O G; -SCOPE_NAME : S C O P E '_' N A M E; -SCOPE_SCHEMA : S C O P E '_' S C H E M A; -SCROLL : S C R O L L; -SEARCH : S E A R C H; -SECOND : S E C O N D; -SECTION : S E C T I O N; -SECURITY : S E C U R I T Y; -SELECT : S E L E C T; -SELF : S E L F; -SENSITIVE : S E N S I T I V E; -SEQUENCE : S E Q U E N C E; -SEQUENCES : S E Q U E N C E S; -SERIALIZABLE : S E R I A L I Z A B L E; -SERVER_NAME : S E R V E R '_' N A M E; -SESSION : S E S S I O N; -SESSION_USER : S E S S I O N '_' U S E R; -SET : S E T; -SETOF : S E T O F; -SETS : S E T S; -SHARE : S H A R E; -SHOW : S H O W; -SIMILAR : S I M I L A R; -SIMPLE : S I M P L E; -SIZE : S I Z E; -SKIP_ : S K I P; // TODO: added manually, fix in docs -SMALLINT : S M A L L I N T; -SNAPSHOT : S N A P S H O T; -SOME : S O M E; -SOURCE : S O U R C E; -SPACE : S P A C E; -SPECIFIC : S P E C I F I C; -SPECIFIC_NAME : S P E C I F I C '_' N A M E; -SPECIFICTYPE : S P E C I F I C T Y P E; -SQL : S Q L; -SQLCODE : S Q L C O D E; -SQLERROR : S Q L E R R O R; -SQLEXCEPTION : S Q L E X C E P T I O N; -SQLSTATE : S Q L S T A T E; -SQLWARNING : S Q L W A R N I N G; -SQRT : S Q R T; -STABLE : S T A B L E; -START : S T A R T; -STATE : S T A T E; -STATEMENT : S T A T E M E N T; -STATIC : S T A T I C; -STATISTICS : S T A T I S T I C S; -STDDEV_POP : S T D D E V '_' P O P; -STDDEV_SAMP : S T D D E V '_' S A M P; -STDIN : S T D I N; -STDOUT : S T D O U T; -STORAGE : S T O R A G E; -STRICT : S T R I C T; -STRUCTURE : S T R U C T U R E; -STYLE : S T Y L E; -SUBCLASS_ORIGIN : S U B C L A S S '_' O R I G I N; -SUBLIST : S U B L I S T; -SUBMULTISET : S U B M U L T I S E T; -SUBSCRIPTION : S U B S C R I P T I O N; -SUBSTRING : S U B S T R I N G; -SUM : S U M; -SYMMETRIC : S Y M M E T R I C; -SYSID : S Y S I D; -SYSTEM : S Y S T E M; -SYSTEM_USER : S Y S T E M '_' U S E R; -TABLE : T A B L E; -TABLE_NAME : T A B L E '_' N A M E; -TABLESAMPLE : T A B L E S A M P L E; -TABLESPACE : T A B L E S P A C E; -TEMP : T E M P; -TEMPLATE : T E M P L A T E; -TEMPORARY : T E M P O R A R Y; -TERMINATE : T E R M I N A T E; -THAN : T H A N; -THEN : T H E N; -TIES : T I E S; -TIME : T I M E; -TIMESTAMP : T I M E S T A M P; -TIMEZONE_HOUR : T I M E Z O N E '_' H O U R; -TIMEZONE_MINUTE : T I M E Z O N E '_' M I N U T E; -TIMING : T I M I N G; -TO : T O; -TOAST : T O A S T; -TOP : T O P; -TOP_LEVEL_COUNT : T O P '_' L E V E L '_' C O U N T; -TRAILING : T R A I L I N G; -TRANSACTION : T R A N S A C T I O N; -TRANSACTION_ACTIVE : T R A N S A C T I O N '_' A C T I V E; -TRANSACTIONS_COMMITTED : T R A N S A C T I O N S '_' C O M M I T T E D; -TRANSACTIONS_ROLLED_BACK : T R A N S A C T I O N S '_' R O L L E D '_' B A C K; -TRANSFORM : T R A N S F O R M; -TRANSFORMS : T R A N S F O R M S; -TRANSLATE : T R A N S L A T E; -TRANSLATION : T R A N S L A T I O N; -TREAT : T R E A T; -TRIGGER : T R I G G E R; -TRIGGER_CATALOG : T R I G G E R '_' C A T A L O G; -TRIGGER_NAME : T R I G G E R '_' N A M E; -TRIGGER_SCHEMA : T R I G G E R '_' S C H E M A; -TRIM : T R I M; -TRUE : T R U E; -TRUNCATE : T R U N C A T E; -TRUSTED : T R U S T E D; -TYPE : T Y P E; -UESCAPE : U E S C A P E; -UNBOUNDED : U N B O U N D E D; -UNCOMMITTED : U N C O M M I T T E D; -UNDER : U N D E R; -UNENCRYPTED : U N E N C R Y P T E D; -UNION : U N I O N; -UNIQUE : U N I Q U E; -UNKNOWN : U N K N O W N; -UNLISTEN : U N L I S T E N; -UNLOGGED : U N L O G G E D; -UNNAMED : U N N A M E D; -UNNEST : U N N E S T; -UNTIL : U N T I L; -UPDATE : U P D A T E; -UPPER : U P P E R; -USAGE : U S A G E; -USER : U S E R; -USER_DEFINED_TYPE_CATALOG : U S E R '_' D E F I N E D '_' T Y P E '_' C A T A L O G; -USER_DEFINED_TYPE_CODE : U S E R '_' D E F I N E D '_' T Y P E '_' C O D E; -USER_DEFINED_TYPE_NAME : U S E R '_' D E F I N E D '_' T Y P E '_' N A M E; -USER_DEFINED_TYPE_SCHEMA : U S E R '_' D E F I N E D '_' T Y P E '_' S C H E M A; -USING : U S I N G; -VACUUM : V A C U U M; -VALID : V A L I D; -VALIDATE : V A L I D A T E; -VALIDATOR : V A L I D A T O R; -VALUE : V A L U E; -VALUES : V A L U E S; -VAR_POP : V A R '_' P O P; -VAR_SAMP : V A R '_' S A M P; -VARCHAR : V A R C H A R; -VARIABLE : V A R I A B L E; -VARIADIC : V A R I A D I C; // TODO: added manually, fix in docs -VARYING : V A R Y I N G; -VERBOSE : V E R B O S E; -VIEW : V I E W; -VOLATILE : V O L A T I L E; -WHEN : W H E N; -WHENEVER : W H E N E V E R; -WHERE : W H E R E; -WIDTH_BUCKET : W I D T H '_' B U C K E T; -WINDOW : W I N D O W; -WITH : W I T H; -WITHIN : W I T H I N; -WITHOUT : W I T H O U T; -WORK : W O R K; -WRITE : W R I T E; -YAML : Y A M L; -YEAR : Y E A R; -YES : Y E S; -ZONE : Z O N E; +// SPECIAL CHARACTERS (4.1.4) -// role options -SUPERUSER : S U P E R U S E R; -NOSUPERUSER : N O S U P E R U S E R; -CREATEROLE : C R E A T E R O L E; -NOCREATEROLE : N O C R E A T E R O L E; -INHERIT : I N H E R I T; -NOINHERIT : N O I N H E R I T; -LOGIN : L O G I N; -NOLOGIN : N O L O G I N; -REPLICATION : R E P L I C A T I O N; -NOREPLICATION : N O R E P L I C A T I O N; -BYPASSRLS : B Y P A S S R L S; -NOBYPASSRLS : N O B Y P A S S R L S; +// -// create aggregate options -SFUNC : S F U N C; -STYPE : S T Y P E; -SSPACE : S S P A C E; -FINALFUNC : F I N A L F U N C; -FINALFUNC_EXTRA : F I N A L F U N C '_' E X T R A; -COMBINEFUNC : C O M B I N E F U N C; -SERIALFUNC : S E R I A L F U N C; -DESERIALFUNC : D E S E R I A L F U N C; -INITCOND : I N I T C O N D; -MSFUNC : M S F U N C; -MINVFUNC : M I N V F U N C; -MSTYPE : M S T Y P E; -MSSPACE : M S S P A C E; -MFINALFUNC : M F I N A L F U N C; -MFINALFUNC_EXTRA : M F I N A L F U N C '_' E X T R A; -MINITCOND : M I N I T C O N D; -SORTOP : S O R T O P; -PARALLEL : P A R A L L E L; -HYPOTHETICAL : H Y P O T H E T I C A L; -SAFE : S A F E; -RESTRICTED : R E S T R I C T E D; -UNSAFE : U N S A F E; -BASETYPE : B A S E T Y P E; +// Note that Asterisk is a valid operator, but does not have the type Operator due to its syntactic use in locations -// create collation -IF : I F; +// that are not expressions. -// create collation options -LOCALE : L O C A L E; -LC_COLLATE : L C '_' C O L L A T E; -LC_CTYPE : L C '_' C T Y P E; -PROVIDER : P R O V I D E R; -VERSION : V E R S I O N; +Dollar: '$'; -// create database fields -ALLOW_CONNECTIONS : A L L O W '_' C O N N E C T I O N S ; -IS_TEMPLATE : I S '_' T E M P L A T E ; +OPEN_PAREN: '('; -// create event -EVENT : E V E N T; +CLOSE_PAREN: ')'; -// create foreign data wrapper -WRAPPER : W R A P P E R; +OPEN_BRACKET: '['; -// create foreign table -SERVER : S E R V E R; +CLOSE_BRACKET: ']'; -// create index -BTREE : B T R E E; -HASH_ : H A S H; -GIST : G I S T; -SPGIST : S P G I S T; -GIN : G I N; -BRIN : B R I N; -CONCURRENTLY : C O N C U R R E N T L Y; +COMMA: ','; -// create language -INLINE : I N L I N E; +SEMI: ';'; -// create materialized view -MATERIALIZED : M A T E R I A L I Z E D; +COLON: ':'; -// create operator -LEFTARG : L E F T A R G; -RIGHTARG : R I G H T A R G; -COMMUTATOR : C O M M U T A T O R; -NEGATOR : N E G A T O R; -HASHES : H A S H E S; -MERGES : M E R G E S; +QUESTION: '?'; -// create operator family -FAMILY : F A M I L Y; +STAR: '*'; -// create policy -POLICY : P O L I C Y; +EQUAL: '='; -// create sequence -OWNED : O W N E D; +DOT: '.'; +//NamedArgument : ':='; -// builtin types that are not reserved keywords that are used in prefix type casts (i.e. {type} {expr}) -ABSTIME : A B S T I M E; -BIGSERIAL : B I G S E R I A L; -BIT_VARYING : B I T ' ' V A R Y I N G; -BOOL : B O O L; -BOX : B O X; -BYTEA : B Y T E A; -CHARACTER_VARYING : C H A R A C T E R ' ' V A R Y I N G; -CIDR : C I D R; -CIRCLE : C I R C L E; -FLOAT4 : F L O A T '4'; -FLOAT8 : F L O A T '8'; -INET : I N E T; -INT2 : I N T '2'; -INT4 : I N T '4'; -INT8 : I N T '8'; -JSON : J S O N; -JSONB : J S O N B; -LINE : L I N E; -LSEG : L S E G; -MACADDR : M A C A D D R; -MACADDR8 : M A C A D D R '8'; -MONEY : M O N E Y; -PG_LSN : P G '_' L S N; -POINT : P O I N T; -POLYGON : P O L Y G O N; -RELTIME : R E L T I M E; -SERIAL : S E R I A L; -SERIAL2 : S E R I A L '2'; -SERIAL4 : S E R I A L '4'; -SERIAL8 : S E R I A L '8'; -SMALLSERIAL : S M A L L S E R I A L; -STSTEM : S T S T E M; -TEXT : T E X T; -TIMESTAMPTZ : T I M E S T A M P T Z; -TIMETZ : T I M E T Z; -TSQUERY : T S Q U E R Y; -TSVECTOR : T S V E C T O R; -TXID_SNAPSHOT : T X I D '_' S N A P S H O T; -UUID : U U I D; -VARBIT : V A R B I T; -XML : X M L; +PLUS: '+'; -// language tokens -COMMA : ','; -COLON : ':'; -COLON_COLON : '::'; -DOLLAR : '$'; -DOLLAR_DOLLAR : '$$'; -STAR : '*'; -OPEN_PAREN : '('; -CLOSE_PAREN : ')'; -OPEN_BRACKET : '['; -CLOSE_BRACKET : ']'; -BIT_STRING : B '\'' ('0'|'1')* '\''; -REGEX_STRING : E SQUOTA_STRING; -NUMERIC_LITERAL : '-'? DEC_DIGIT+ '.' DEC_DIGIT+ (E ('-')* DEC_DIGIT+)?; -INTEGER_LITERAL : '-'? DEC_DIGIT+ (E DEC_DIGIT+)?; -HEX_INTEGER_LITERAL : 'x' SQUOTA_STRING; -DOT : '.'; -SINGLEQ_STRING_LITERAL : SQUOTA_STRING; -DOUBLEQ_STRING_LITERAL : DQUOTA_STRING; -IDENTIFIER : [a-zA-Z_][a-zA-Z_0-9$]*; -DOLLAR_DEC : '$' DEC_DIGIT+; -IDENTIFIER_UNICODE : [a-zA-Z_\u00A1-\uFFFF][a-zA-Z_\u00A1-\uFFFF0-9$]*; +MINUS: '-'; -// operator tokens -AMP : '&'; -AMP_AMP : '&&'; -AMP_LT : '&<'; -AT_AT : '@@'; -AT_GT : '@>'; -AT_SIGN : '@'; -BANG : '!'; -BANG_BANG : '!!'; -BANG_EQUAL : '!='; -CARET : '^'; -EQUAL : '='; -EQUAL_GT : '=>'; -GT : '>'; -GTE : '>='; -GT_GT : '>>'; -HASH : '#'; -HASH_EQ : '#='; -HASH_GT : '#>'; -HASH_GT_GT : '#>>'; -HASH_HASH : '##'; -HYPHEN_GT : '->'; -HYPHEN_GT_GT : '->>'; -HYPHEN_PIPE_HYPHEN : '-|-'; -LT : '<'; -LTE : '<='; -LT_AT : '<@'; -LT_CARET : '<^'; -LT_GT : '<>'; -LT_HYPHEN_GT : '<->'; -LT_LT : '<<'; -LT_LT_EQ : '<<='; -LT_QMARK_GT : ''; -MINUS : '-'; -PERCENT : '%'; -PIPE : '|'; -PIPE_PIPE : '||'; -PIPE_PIPE_SLASH : '||/'; -PIPE_SLASH : '|/'; -PLUS : '+'; -QMARK : '?'; -QMARK_AMP : '?&'; -QMARK_HASH : '?#'; -QMARK_HYPHEN : '?-'; -QMARK_PIPE : '?|'; -SLASH : '/'; -TIL : '~'; -TIL_EQ : '~='; -TIL_GTE_TIL : '~>=~'; -TIL_GT_TIL : '~>~'; -TIL_LTE_TIL : '~<=~'; -TIL_LT_TIL : '~<~'; -TIL_STAR : '~*'; -TIL_TIL : '~~'; -SEMI: ';'; +SLASH: '/'; -SPEL : '#{' ANYTHING '}'; -fragment ANYTHING : (.)*?; +CARET: '^'; + +LT: '<'; + +GT: '>'; + +LESS_LESS: '<<'; + +GREATER_GREATER: '>>'; + +COLON_EQUALS: ':='; + +LESS_EQUALS: '<='; + +EQUALS_GREATER: '=>'; + +GREATER_EQUALS: '>='; + +DOT_DOT: '..'; + +NOT_EQUALS: '<>'; + +TYPECAST: '::'; + +PERCENT: '%'; + +PARAM: '$' ([0-9])+; +// + +// OPERATORS (4.1.3) + +// + +// this rule does not allow + or - at the end of a multi-character operator + +Operator: + ( + ( + OperatorCharacter + | ('+' | '-' {checkLA('-')}?)+ (OperatorCharacter | '/' {checkLA('*')}?) + | '/' {checkLA('*')}? + )+ + | // special handling for the single-character operators + and - + [+-] + | ('?#' | '?-' | '?-|' | '?|' | '?||' | '') + ) + //TODO somehow rewrite this part without using Actions + { + HandleLessLessGreaterGreater(); + } +; +/* This rule handles operators which end with + or -, and sets the token type to Operator. It is comprised of four + * parts, in order: + * + * 1. A prefix, which does not contain a character from the required set which allows + or - to appear at the end of + * the operator. + * 2. A character from the required set which allows + or - to appear at the end of the operator. + * 3. An optional sub-token which takes the form of an operator which does not include a + or - at the end of the + * sub-token. + * 4. A suffix sequence of + and - characters. + */ + +OperatorEndingWithPlusMinus: + (OperatorCharacterNotAllowPlusMinusAtEnd | '-' {checkLA('-')}? | '/' {checkLA('*')}?)* OperatorCharacterAllowPlusMinusAtEnd Operator? ( + '+' + | '-' {checkLA('-')}? + )+ -> type (Operator) +; +// Each of the following fragment rules omits the +, -, and / characters, which must always be handled in a special way + +// by the operator rules above. + +fragment OperatorCharacter: [*<>=~!@%^&|`#]; +// these are the operator characters that don't count towards one ending with + or - + +fragment OperatorCharacterNotAllowPlusMinusAtEnd: [*<>=+]; +// an operator may end with + or - if it contains one of these characters + +fragment OperatorCharacterAllowPlusMinusAtEnd: [~!@%^&|`#]; +// + +// KEYWORDS (Appendix C) + +// + +// + +// reserved keywords + +// + +ALL: 'ALL'; + +ANALYSE: 'ANALYSE'; + +ANALYZE: 'ANALYZE'; + +AND: 'AND'; + +ANY: 'ANY'; + +ARRAY: 'ARRAY'; + +AS: 'AS'; + +ASC: 'ASC'; + +ASYMMETRIC: 'ASYMMETRIC'; + +BOTH: 'BOTH'; + +CASE: 'CASE'; + +CAST: 'CAST'; + +CHECK: 'CHECK'; + +COLLATE: 'COLLATE'; + +COLUMN: 'COLUMN'; + +CONSTRAINT: 'CONSTRAINT'; + +CREATE: 'CREATE'; + +CURRENT_CATALOG: 'CURRENT_CATALOG'; + +CURRENT_DATE: 'CURRENT_DATE'; + +CURRENT_ROLE: 'CURRENT_ROLE'; + +CURRENT_TIME: 'CURRENT_TIME'; + +CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'; + +CURRENT_USER: 'CURRENT_USER'; + +DEFAULT: 'DEFAULT'; + +DEFERRABLE: 'DEFERRABLE'; + +DESC: 'DESC'; + +DISTINCT: 'DISTINCT'; + +DO: 'DO'; + +ELSE: 'ELSE'; + +EXCEPT: 'EXCEPT'; + +FALSE_P: 'FALSE'; + +FETCH: 'FETCH'; + +FOR: 'FOR'; + +FOREIGN: 'FOREIGN'; + +FROM: 'FROM'; + +GRANT: 'GRANT'; + +GROUP_P: 'GROUP'; + +HAVING: 'HAVING'; + +IN_P: 'IN'; + +INITIALLY: 'INITIALLY'; + +INTERSECT: 'INTERSECT'; + +INTO: 'INTO'; + +LATERAL_P: 'LATERAL'; + +LEADING: 'LEADING'; + +LIMIT: 'LIMIT'; + +LOCALTIME: 'LOCALTIME'; + +LOCALTIMESTAMP: 'LOCALTIMESTAMP'; + +NOT: 'NOT'; + +NULL_P: 'NULL'; + +OFFSET: 'OFFSET'; + +ON: 'ON'; + +ONLY: 'ONLY'; + +OR: 'OR'; + +ORDER: 'ORDER'; + +PLACING: 'PLACING'; + +PRIMARY: 'PRIMARY'; + +REFERENCES: 'REFERENCES'; + +RETURNING: 'RETURNING'; + +SELECT: 'SELECT'; + +SESSION_USER: 'SESSION_USER'; + +SOME: 'SOME'; + +SYMMETRIC: 'SYMMETRIC'; + +TABLE: 'TABLE'; + +THEN: 'THEN'; + +TO: 'TO'; + +TRAILING: 'TRAILING'; + +TRUE_P: 'TRUE'; + +UNION: 'UNION'; + +UNIQUE: 'UNIQUE'; + +USER: 'USER'; + +USING: 'USING'; + +VARIADIC: 'VARIADIC'; + +WHEN: 'WHEN'; + +WHERE: 'WHERE'; + +WINDOW: 'WINDOW'; + +WITH: 'WITH'; + +// + +// reserved keywords (can be function or type) + +// + +AUTHORIZATION: 'AUTHORIZATION'; + +BINARY: 'BINARY'; + +COLLATION: 'COLLATION'; + +CONCURRENTLY: 'CONCURRENTLY'; + +CROSS: 'CROSS'; + +CURRENT_SCHEMA: 'CURRENT_SCHEMA'; + +FREEZE: 'FREEZE'; + +FULL: 'FULL'; + +ILIKE: 'ILIKE'; + +INNER_P: 'INNER'; + +IS: 'IS'; + +ISNULL: 'ISNULL'; + +JOIN: 'JOIN'; + +LEFT: 'LEFT'; + +LIKE: 'LIKE'; + +NATURAL: 'NATURAL'; + +NOTNULL: 'NOTNULL'; + +OUTER_P: 'OUTER'; + +OVER: 'OVER'; + +OVERLAPS: 'OVERLAPS'; + +RIGHT: 'RIGHT'; + +SIMILAR: 'SIMILAR'; + +VERBOSE: 'VERBOSE'; +// + +// non-reserved keywords + +// + +ABORT_P: 'ABORT'; + +ABSOLUTE_P: 'ABSOLUTE'; + +ACCESS: 'ACCESS'; + +ACTION: 'ACTION'; + +ADD_P: 'ADD'; + +ADMIN: 'ADMIN'; + +AFTER: 'AFTER'; + +AGGREGATE: 'AGGREGATE'; + +ALSO: 'ALSO'; + +ALTER: 'ALTER'; + +ALWAYS: 'ALWAYS'; + +ASSERTION: 'ASSERTION'; + +ASSIGNMENT: 'ASSIGNMENT'; + +AT: 'AT'; + +ATTRIBUTE: 'ATTRIBUTE'; + +BACKWARD: 'BACKWARD'; + +BEFORE: 'BEFORE'; + +BEGIN_P: 'BEGIN'; + +BY: 'BY'; + +CACHE: 'CACHE'; + +CALLED: 'CALLED'; + +CASCADE: 'CASCADE'; + +CASCADED: 'CASCADED'; + +CATALOG: 'CATALOG'; + +CHAIN: 'CHAIN'; + +CHARACTERISTICS: 'CHARACTERISTICS'; + +CHECKPOINT: 'CHECKPOINT'; + +CLASS: 'CLASS'; + +CLOSE: 'CLOSE'; + +CLUSTER: 'CLUSTER'; + +COMMENT: 'COMMENT'; + +COMMENTS: 'COMMENTS'; + +COMMIT: 'COMMIT'; + +COMMITTED: 'COMMITTED'; + +CONFIGURATION: 'CONFIGURATION'; + +CONNECTION: 'CONNECTION'; + +CONSTRAINTS: 'CONSTRAINTS'; + +CONTENT_P: 'CONTENT'; + +CONTINUE_P: 'CONTINUE'; + +CONVERSION_P: 'CONVERSION'; + +COPY: 'COPY'; + +COST: 'COST'; + +CSV: 'CSV'; + +CURSOR: 'CURSOR'; + +CYCLE: 'CYCLE'; + +DATA_P: 'DATA'; + +DATABASE: 'DATABASE'; + +DAY_P: 'DAY'; + +DEALLOCATE: 'DEALLOCATE'; + +DECLARE: 'DECLARE'; + +DEFAULTS: 'DEFAULTS'; + +DEFERRED: 'DEFERRED'; + +DEFINER: 'DEFINER'; + +DELETE_P: 'DELETE'; + +DELIMITER: 'DELIMITER'; + +DELIMITERS: 'DELIMITERS'; + +DICTIONARY: 'DICTIONARY'; + +DISABLE_P: 'DISABLE'; + +DISCARD: 'DISCARD'; + +DOCUMENT_P: 'DOCUMENT'; + +DOMAIN_P: 'DOMAIN'; + +DOUBLE_P: 'DOUBLE'; + +DROP: 'DROP'; + +EACH: 'EACH'; + +ENABLE_P: 'ENABLE'; + +ENCODING: 'ENCODING'; + +ENCRYPTED: 'ENCRYPTED'; + +ENUM_P: 'ENUM'; + +ESCAPE: 'ESCAPE'; + +EVENT: 'EVENT'; + +EXCLUDE: 'EXCLUDE'; + +EXCLUDING: 'EXCLUDING'; + +EXCLUSIVE: 'EXCLUSIVE'; + +EXECUTE: 'EXECUTE'; + +EXPLAIN: 'EXPLAIN'; + +EXTENSION: 'EXTENSION'; + +EXTERNAL: 'EXTERNAL'; + +FAMILY: 'FAMILY'; + +FIRST_P: 'FIRST'; + +FOLLOWING: 'FOLLOWING'; + +FORCE: 'FORCE'; + +FORWARD: 'FORWARD'; + +FUNCTION: 'FUNCTION'; + +FUNCTIONS: 'FUNCTIONS'; + +GLOBAL: 'GLOBAL'; + +GRANTED: 'GRANTED'; + +HANDLER: 'HANDLER'; + +HEADER_P: 'HEADER'; + +HOLD: 'HOLD'; + +HOUR_P: 'HOUR'; + +IDENTITY_P: 'IDENTITY'; + +IF_P: 'IF'; + +IMMEDIATE: 'IMMEDIATE'; + +IMMUTABLE: 'IMMUTABLE'; + +IMPLICIT_P: 'IMPLICIT'; + +INCLUDING: 'INCLUDING'; + +INCREMENT: 'INCREMENT'; + +INDEX: 'INDEX'; + +INDEXES: 'INDEXES'; + +INHERIT: 'INHERIT'; + +INHERITS: 'INHERITS'; + +INLINE_P: 'INLINE'; + +INSENSITIVE: 'INSENSITIVE'; + +INSERT: 'INSERT'; + +INSTEAD: 'INSTEAD'; + +INVOKER: 'INVOKER'; + +ISOLATION: 'ISOLATION'; + +KEY: 'KEY'; + +LABEL: 'LABEL'; + +LANGUAGE: 'LANGUAGE'; + +LARGE_P: 'LARGE'; + +LAST_P: 'LAST'; +//LC_COLLATE : 'LC'_'COLLATE; + +//LC_CTYPE : 'LC'_'CTYPE; + +LEAKPROOF: 'LEAKPROOF'; + +LEVEL: 'LEVEL'; + +LISTEN: 'LISTEN'; + +LOAD: 'LOAD'; + +LOCAL: 'LOCAL'; + +LOCATION: 'LOCATION'; + +LOCK_P: 'LOCK'; + +MAPPING: 'MAPPING'; + +MATCH: 'MATCH'; + +MATCHED: 'MATCHED'; + +MATERIALIZED: 'MATERIALIZED'; + +MAXVALUE: 'MAXVALUE'; + +MERGE: 'MERGE'; + +MINUTE_P: 'MINUTE'; + +MINVALUE: 'MINVALUE'; + +MODE: 'MODE'; + +MONTH_P: 'MONTH'; + +MOVE: 'MOVE'; + +NAME_P: 'NAME'; + +NAMES: 'NAMES'; + +NEXT: 'NEXT'; + +NO: 'NO'; + +NOTHING: 'NOTHING'; + +NOTIFY: 'NOTIFY'; + +NOWAIT: 'NOWAIT'; + +NULLS_P: 'NULLS'; + +OBJECT_P: 'OBJECT'; + +OF: 'OF'; + +OFF: 'OFF'; + +OIDS: 'OIDS'; + +OPERATOR: 'OPERATOR'; + +OPTION: 'OPTION'; + +OPTIONS: 'OPTIONS'; + +OWNED: 'OWNED'; + +OWNER: 'OWNER'; + +PARSER: 'PARSER'; + +PARTIAL: 'PARTIAL'; + +PARTITION: 'PARTITION'; + +PASSING: 'PASSING'; + +PASSWORD: 'PASSWORD'; + +PLANS: 'PLANS'; + +PRECEDING: 'PRECEDING'; + +PREPARE: 'PREPARE'; + +PREPARED: 'PREPARED'; + +PRESERVE: 'PRESERVE'; + +PRIOR: 'PRIOR'; + +PRIVILEGES: 'PRIVILEGES'; + +PROCEDURAL: 'PROCEDURAL'; + +PROCEDURE: 'PROCEDURE'; + +PROGRAM: 'PROGRAM'; + +QUOTE: 'QUOTE'; + +RANGE: 'RANGE'; + +READ: 'READ'; + +REASSIGN: 'REASSIGN'; + +RECHECK: 'RECHECK'; + +RECURSIVE: 'RECURSIVE'; + +REF: 'REF'; + +REFRESH: 'REFRESH'; + +REINDEX: 'REINDEX'; + +RELATIVE_P: 'RELATIVE'; + +RELEASE: 'RELEASE'; + +RENAME: 'RENAME'; + +REPEATABLE: 'REPEATABLE'; + +REPLACE: 'REPLACE'; + +REPLICA: 'REPLICA'; + +RESET: 'RESET'; + +RESTART: 'RESTART'; + +RESTRICT: 'RESTRICT'; + +RETURNS: 'RETURNS'; + +REVOKE: 'REVOKE'; + +ROLE: 'ROLE'; + +ROLLBACK: 'ROLLBACK'; + +ROWS: 'ROWS'; + +RULE: 'RULE'; + +SAVEPOINT: 'SAVEPOINT'; + +SCHEMA: 'SCHEMA'; + +SCROLL: 'SCROLL'; + +SEARCH: 'SEARCH'; + +SECOND_P: 'SECOND'; + +SECURITY: 'SECURITY'; + +SEQUENCE: 'SEQUENCE'; + +SEQUENCES: 'SEQUENCES'; + +SERIALIZABLE: 'SERIALIZABLE'; + +SERVER: 'SERVER'; + +SESSION: 'SESSION'; + +SET: 'SET'; + +SHARE: 'SHARE'; + +SHOW: 'SHOW'; + +SIMPLE: 'SIMPLE'; + +SNAPSHOT: 'SNAPSHOT'; + +STABLE: 'STABLE'; + +STANDALONE_P: 'STANDALONE'; + +START: 'START'; + +STATEMENT: 'STATEMENT'; + +STATISTICS: 'STATISTICS'; + +STDIN: 'STDIN'; + +STDOUT: 'STDOUT'; + +STORAGE: 'STORAGE'; + +STRICT_P: 'STRICT'; + +STRIP_P: 'STRIP'; + +SYSID: 'SYSID'; + +SYSTEM_P: 'SYSTEM'; + +TABLES: 'TABLES'; + +TABLESPACE: 'TABLESPACE'; + +TEMP: 'TEMP'; + +TEMPLATE: 'TEMPLATE'; + +TEMPORARY: 'TEMPORARY'; + +TEXT_P: 'TEXT'; + +TRANSACTION: 'TRANSACTION'; + +TRIGGER: 'TRIGGER'; + +TRUNCATE: 'TRUNCATE'; + +TRUSTED: 'TRUSTED'; + +TYPE_P: 'TYPE'; + +TYPES_P: 'TYPES'; + +UNBOUNDED: 'UNBOUNDED'; + +UNCOMMITTED: 'UNCOMMITTED'; + +UNENCRYPTED: 'UNENCRYPTED'; + +UNKNOWN: 'UNKNOWN'; + +UNLISTEN: 'UNLISTEN'; + +UNLOGGED: 'UNLOGGED'; + +UNTIL: 'UNTIL'; + +UPDATE: 'UPDATE'; + +VACUUM: 'VACUUM'; + +VALID: 'VALID'; + +VALIDATE: 'VALIDATE'; + +VALIDATOR: 'VALIDATOR'; +//VALUE : 'VALUE; + +VARYING: 'VARYING'; + +VERSION_P: 'VERSION'; + +VIEW: 'VIEW'; + +VOLATILE: 'VOLATILE'; + +WHITESPACE_P: 'WHITESPACE'; + +WITHOUT: 'WITHOUT'; + +WORK: 'WORK'; + +WRAPPER: 'WRAPPER'; + +WRITE: 'WRITE'; + +XML_P: 'XML'; + +YEAR_P: 'YEAR'; + +YES_P: 'YES'; + +ZONE: 'ZONE'; +// + +// non-reserved keywords (can not be function or type) + +// + +BETWEEN: 'BETWEEN'; + +BIGINT: 'BIGINT'; + +BIT: 'BIT'; + +BOOLEAN_P: 'BOOLEAN'; + +CHAR_P: 'CHAR'; + +CHARACTER: 'CHARACTER'; + +COALESCE: 'COALESCE'; + +DEC: 'DEC'; + +DECIMAL_P: 'DECIMAL'; + +EXISTS: 'EXISTS'; + +EXTRACT: 'EXTRACT'; + +FLOAT_P: 'FLOAT'; + +GREATEST: 'GREATEST'; + +INOUT: 'INOUT'; + +INT_P: 'INT'; + +INTEGER: 'INTEGER'; + +INTERVAL: 'INTERVAL'; + +LEAST: 'LEAST'; + +NATIONAL: 'NATIONAL'; + +NCHAR: 'NCHAR'; + +NONE: 'NONE'; + +NULLIF: 'NULLIF'; + +NUMERIC: 'NUMERIC'; + +OVERLAY: 'OVERLAY'; + +POSITION: 'POSITION'; + +PRECISION: 'PRECISION'; + +REAL: 'REAL'; + +ROW: 'ROW'; + +SETOF: 'SETOF'; + +SMALLINT: 'SMALLINT'; + +SUBSTRING: 'SUBSTRING'; + +TIME: 'TIME'; + +TIMESTAMP: 'TIMESTAMP'; + +TREAT: 'TREAT'; + +TRIM: 'TRIM'; + +VALUES: 'VALUES'; + +VARCHAR: 'VARCHAR'; + +XMLATTRIBUTES: 'XMLATTRIBUTES'; + +XMLCOMMENT: 'XMLCOMMENT'; + +XMLAGG: 'XMLAGG'; + +XML_IS_WELL_FORMED: 'XML_IS_WELL_FORMED'; + +XML_IS_WELL_FORMED_DOCUMENT: 'XML_IS_WELL_FORMED_DOCUMENT'; + +XML_IS_WELL_FORMED_CONTENT: 'XML_IS_WELL_FORMED_CONTENT'; + +XPATH: 'XPATH'; + +XPATH_EXISTS: 'XPATH_EXISTS'; + +XMLCONCAT: 'XMLCONCAT'; + +XMLELEMENT: 'XMLELEMENT'; + +XMLEXISTS: 'XMLEXISTS'; + +XMLFOREST: 'XMLFOREST'; + +XMLPARSE: 'XMLPARSE'; + +XMLPI: 'XMLPI'; + +XMLROOT: 'XMLROOT'; + +XMLSERIALIZE: 'XMLSERIALIZE'; +//MISSED + +CALL: 'CALL'; + +CURRENT_P: 'CURRENT'; + +ATTACH: 'ATTACH'; + +DETACH: 'DETACH'; + +EXPRESSION: 'EXPRESSION'; + +GENERATED: 'GENERATED'; + +LOGGED: 'LOGGED'; + +STORED: 'STORED'; + +INCLUDE: 'INCLUDE'; + +ROUTINE: 'ROUTINE'; + +TRANSFORM: 'TRANSFORM'; + +IMPORT_P: 'IMPORT'; + +POLICY: 'POLICY'; + +METHOD: 'METHOD'; + +REFERENCING: 'REFERENCING'; + +NEW: 'NEW'; + +OLD: 'OLD'; + +VALUE_P: 'VALUE'; + +SUBSCRIPTION: 'SUBSCRIPTION'; + +PUBLICATION: 'PUBLICATION'; + +OUT_P: 'OUT'; + +END_P: 'END'; + +ROUTINES: 'ROUTINES'; + +SCHEMAS: 'SCHEMAS'; + +PROCEDURES: 'PROCEDURES'; + +INPUT_P: 'INPUT'; + +SUPPORT: 'SUPPORT'; + +PARALLEL: 'PARALLEL'; + +SQL_P: 'SQL'; + +DEPENDS: 'DEPENDS'; + +OVERRIDING: 'OVERRIDING'; + +CONFLICT: 'CONFLICT'; + +SKIP_P: 'SKIP'; + +LOCKED: 'LOCKED'; + +TIES: 'TIES'; + +ROLLUP: 'ROLLUP'; + +CUBE: 'CUBE'; + +GROUPING: 'GROUPING'; + +SETS: 'SETS'; + +TABLESAMPLE: 'TABLESAMPLE'; + +ORDINALITY: 'ORDINALITY'; + +XMLTABLE: 'XMLTABLE'; + +COLUMNS: 'COLUMNS'; + +XMLNAMESPACES: 'XMLNAMESPACES'; + +ROWTYPE: 'ROWTYPE'; + +NORMALIZED: 'NORMALIZED'; + +WITHIN: 'WITHIN'; + +FILTER: 'FILTER'; + +GROUPS: 'GROUPS'; + +OTHERS: 'OTHERS'; + +NFC: 'NFC'; + +NFD: 'NFD'; + +NFKC: 'NFKC'; + +NFKD: 'NFKD'; + +UESCAPE: 'UESCAPE'; + +VIEWS: 'VIEWS'; + +NORMALIZE: 'NORMALIZE'; + +DUMP: 'DUMP'; + +PRINT_STRICT_PARAMS: 'PRINT_STRICT_PARAMS'; + +VARIABLE_CONFLICT: 'VARIABLE_CONFLICT'; + +ERROR: 'ERROR'; + +USE_VARIABLE: 'USE_VARIABLE'; + +USE_COLUMN: 'USE_COLUMN'; + +ALIAS: 'ALIAS'; + +CONSTANT: 'CONSTANT'; + +PERFORM: 'PERFORM'; + +GET: 'GET'; + +DIAGNOSTICS: 'DIAGNOSTICS'; + +STACKED: 'STACKED'; + +ELSIF: 'ELSIF'; + +WHILE: 'WHILE'; + +REVERSE: 'REVERSE'; + +FOREACH: 'FOREACH'; + +SLICE: 'SLICE'; + +EXIT: 'EXIT'; + +RETURN: 'RETURN'; + +QUERY: 'QUERY'; + +RAISE: 'RAISE'; + +SQLSTATE: 'SQLSTATE'; + +DEBUG: 'DEBUG'; + +LOG: 'LOG'; + +INFO: 'INFO'; + +NOTICE: 'NOTICE'; + +WARNING: 'WARNING'; + +EXCEPTION: 'EXCEPTION'; + +ASSERT: 'ASSERT'; + +LOOP: 'LOOP'; + +OPEN: 'OPEN'; + +TOP: 'TOP'; +// + +// IDENTIFIERS (4.1.1) + +// + +ABS: 'ABS'; + +CBRT: 'CBRT'; + +CEIL: 'CEIL'; + +CEILING: 'CEILING'; + +DEGREES: 'DEGREES'; + +DIV: 'DIV'; + +EXP: 'EXP'; + +FACTORIAL: 'FACTORIAL'; + +FLOOR: 'FLOOR'; + +GCD: 'GCD'; + +LCM: 'LCM'; + +LN: 'LN'; + +LOG10: 'LOG10'; + +MIN_SCALE: 'MIN_SCALE'; + +MOD: 'MOD'; + +PI: 'PI'; + +POWER: 'POWER'; + +RADIANS: 'RADIANS'; + +ROUND: 'ROUND'; + +SCALE: 'SCALE'; + +SIGN: 'SIGN'; + +SQRT: 'SQRT'; + +TRIM_SCALE: 'TRIM_SCALE'; + +TRUNC: 'TRUNC'; + +WIDTH_BUCKET: 'WIDTH_BUCKET'; + +RANDOM: 'RANDOM'; + +SETSEED: 'SETSEED'; + +ACOS: 'ACOS'; + +ACOSD: 'ACOSD'; + +ASIN: 'ASIN'; + +ASIND: 'ASIND'; + +ATAN: 'ATAN'; + +ATAND: 'ATAND'; + +ATAN2: 'ATAN2'; + +ATAN2D: 'ATAN2D'; + +COS: 'COS'; + +COSD: 'COSD'; + +COT: 'COT'; + +COTD: 'COTD'; + +SIN: 'SIN'; + +SIND: 'SIND'; + +TAN: 'TAN'; + +TAND: 'TAND'; + +SINH: 'SINH'; + +COSH: 'COSH'; + +TANH: 'TANH'; + +ASINH: 'ASINH'; + +ACOSH: 'ACOSH'; + +ATANH: 'ATANH'; + +BIT_LENGTH: 'BIT_LENGTH'; + +CHAR_LENGTH: 'CHAR_LENGTH'; + +CHARACTER_LENGTH: 'CHARACTER_LENGTH'; + +LOWER: 'LOWER'; + +OCTET_LENGTH: 'OCTET_LENGTH'; + +UPPER: 'UPPER'; + +ASCII: 'ASCII'; + +BTRIM: 'BTRIM'; + +CHR: 'CHR'; + +CONCAT: 'CONCAT'; + +CONCAT_WS: 'CONCAT_WS'; + +FORMAT: 'FORMAT'; + +INITCAP: 'INITCAP'; + +LENGTH: 'LENGTH'; + +LPAD: 'LPAD'; + +LTRIM: 'LTRIM'; + +MD5: 'MD5'; + +PARSE_IDENT: 'PARSE_IDENT'; + +PG_CLIENT_ENCODING: 'PG_CLIENT_ENCODING'; + +QUOTE_IDENT: 'QUOTE_IDENT'; + +QUOTE_LITERAL: 'QUOTE_LITERAL'; + +QUOTE_NULLABLE: 'QUOTE_NULLABLE'; + +REGEXP_COUNT: 'REGEXP_COUNT'; + +REGEXP_INSTR: 'REGEXP_INSTR'; + +REGEXP_LIKE: 'REGEXP_LIKE'; + +REGEXP_MATCH: 'REGEXP_MATCH'; + +REGEXP_MATCHES: 'REGEXP_MATCHES'; + +REGEXP_REPLACE: 'REGEXP_REPLACE'; + +REGEXP_SPLIT_TO_ARRAY: 'REGEXP_SPLIT_TO_ARRAY'; + +REGEXP_SPLIT_TO_TABLE: 'REGEXP_SPLIT_TO_TABLE'; + +REGEXP_SUBSTR: 'REGEXP_SUBSTR'; + +REPEAT: 'REPEAT'; + +RPAD: 'RPAD'; + +RTRIM: 'RTRIM'; + +SPLIT_PART: 'SPLIT_PART'; + +STARTS_WITH: 'STARTS_WITH'; + +STRING_TO_ARRAY: 'STRING_TO_ARRAY'; + +STRING_TO_TABLE: 'STRING_TO_TABLE'; + +STRPOS: 'STRPOS'; + +SUBSTR: 'SUBSTR'; + +TO_ASCII: 'TO_ASCII'; + +TO_HEX: 'TO_HEX'; + +TRANSLATE: 'TRANSLATE'; + +UNISTR: 'UNISTR'; + +AGE: 'AGE'; + +CLOCK_TIMESTAMP: 'CLOCK_TIMESTAMP'; + +DATE_BIN: 'DATE_BIN'; + +DATE_PART: 'DATE_PART'; + +DATE_TRUNC: 'DATE_TRUNC'; + +ISFINITE: 'ISFINITE'; + +JUSTIFY_DAYS: 'JUSTIFY_DAYS'; + +JUSTIFY_HOURS: 'JUSTIFY_HOURS'; + +JUSTIFY_INTERVAL: 'JUSTIFY_INTERVAL'; + +MAKE_DATE: 'MAKE_DATE'; + +MAKE_INTERVAL: 'MAKE_INTERVAL'; + +MAKE_TIME: 'MAKE_TIME'; + +MAKE_TIMESTAMP: 'MAKE_TIMESTAMP'; + +MAKE_TIMESTAMPTZ: 'MAKE_TIMESTAMPTZ'; + +NOW: 'NOW'; + +STATEMENT_TIMESTAMP: 'STATEMENT_TIMESTAMP'; + +TIMEOFDAY: 'TIMEOFDAY'; + +TRANSACTION_TIMESTAMP: 'TRANSACTION_TIMESTAMP'; + +TO_TIMESTAMP: 'TO_TIMESTAMP'; + +TO_CHAR: 'TO_CHAR'; + +TO_DATE: 'TO_DATE'; + +TO_NUMBER: 'TO_NUMBER'; + +Identifier: IdentifierStartChar IdentifierChar*; + +fragment IdentifierStartChar options { + caseInsensitive = false; +}: // these are the valid identifier start characters below 0x7F + [a-zA-Z_] + | // these are the valid characters from 0x80 to 0xFF + [\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF] + | // these are the letters above 0xFF which only need a single UTF-16 code unit + [\u0100-\uD7FF\uE000-\uFFFF] {charIsLetter()}? + | // letters which require multiple UTF-16 code units + [\uD800-\uDBFF] [\uDC00-\uDFFF] { + CheckIfUtf32Letter() + }? +; + +fragment IdentifierChar: StrictIdentifierChar | '$'; + +fragment StrictIdentifierChar: IdentifierStartChar | [0-9]; +/* Quoted Identifiers + * + * These are divided into four separate tokens, allowing distinction of valid quoted identifiers from invalid quoted + * identifiers without sacrificing the ability of the lexer to reliably recover from lexical errors in the input. + */ + +QuotedIdentifier: UnterminatedQuotedIdentifier '"'; +// This is a quoted identifier which only contains valid characters but is not terminated + +UnterminatedQuotedIdentifier: '"' ('""' | ~ [\u0000"])*; +// This is a quoted identifier which is terminated but contains a \u0000 character + +InvalidQuotedIdentifier: InvalidUnterminatedQuotedIdentifier '"'; +// This is a quoted identifier which is unterminated and contains a \u0000 character + +InvalidUnterminatedQuotedIdentifier: '"' ('""' | ~ '"')*; +/* Unicode Quoted Identifiers + * + * These are divided into four separate tokens, allowing distinction of valid Unicode quoted identifiers from invalid + * Unicode quoted identifiers without sacrificing the ability of the lexer to reliably recover from lexical errors in + * the input. Note that escape sequences are never checked as part of this determination due to the ability of users + * to change the escape character with a UESCAPE clause following the Unicode quoted identifier. + * + * TODO: these rules assume "" is still a valid escape sequence within a Unicode quoted identifier. + */ + +UnicodeQuotedIdentifier: 'U' '&' QuotedIdentifier; +// This is a Unicode quoted identifier which only contains valid characters but is not terminated + +UnterminatedUnicodeQuotedIdentifier: 'U' '&' UnterminatedQuotedIdentifier; +// This is a Unicode quoted identifier which is terminated but contains a \u0000 character + +InvalidUnicodeQuotedIdentifier: 'U' '&' InvalidQuotedIdentifier; +// This is a Unicode quoted identifier which is unterminated and contains a \u0000 character + +InvalidUnterminatedUnicodeQuotedIdentifier: 'U' '&' InvalidUnterminatedQuotedIdentifier; +// + +// CONSTANTS (4.1.2) + +// + +// String Constants (4.1.2.1) + +StringConstant: UnterminatedStringConstant '\''; + +UnterminatedStringConstant: '\'' ('\'\'' | ~ '\'' | '\\\\\'' | '\\\'')*; +// String Constants with C-style Escapes (4.1.2.2) + +BeginEscapeStringConstant: 'E' '\'' -> more, pushMode (EscapeStringConstantMode); +// String Constants with Unicode Escapes (4.1.2.3) + +// + +// Note that escape sequences are never checked as part of this token due to the ability of users to change the escape + +// character with a UESCAPE clause following the Unicode string constant. + +// + +// TODO: these rules assume '' is still a valid escape sequence within a Unicode string constant. + +UnicodeEscapeStringConstant: UnterminatedUnicodeEscapeStringConstant '\''; + +UnterminatedUnicodeEscapeStringConstant: 'U' '&' UnterminatedStringConstant; +// Dollar-quoted String Constants (4.1.2.4) + +BeginDollarStringConstant: '$' Tag? '$' {pushTag();} -> pushMode (DollarQuotedStringMode); +/* "The tag, if any, of a dollar-quoted string follows the same rules as an + * unquoted identifier, except that it cannot contain a dollar sign." + */ + +fragment Tag: IdentifierStartChar StrictIdentifierChar*; +// Bit-strings Constants (4.1.2.5) + +BinaryStringConstant: UnterminatedBinaryStringConstant '\''; + +UnterminatedBinaryStringConstant: 'B' '\'' [01]*; + +InvalidBinaryStringConstant: InvalidUnterminatedBinaryStringConstant '\''; + +InvalidUnterminatedBinaryStringConstant: 'B' UnterminatedStringConstant; + +HexadecimalStringConstant: UnterminatedHexadecimalStringConstant '\''; + +UnterminatedHexadecimalStringConstant: 'X' '\'' [0-9A-F]*; + +InvalidHexadecimalStringConstant: InvalidUnterminatedHexadecimalStringConstant '\''; + +InvalidUnterminatedHexadecimalStringConstant: 'X' UnterminatedStringConstant; +// Numeric Constants (4.1.2.6) + +Integral: Digits; + +NumericFail: Digits '..' {HandleNumericFail();}; + +Numeric: + Digits '.' Digits? /*? replaced with + to solve problem with DOT_DOT .. but this surely must be rewriten */ ( + 'E' [+-]? Digits + )? + | '.' Digits ('E' [+-]? Digits)? + | Digits 'E' [+-]? Digits +; + +fragment Digits: [0-9]+; + +PLSQLIDENTIFIER: ':"' ('\\' . | '""' | ~ ('"' | '\\'))* '"'; +// + +// WHITESPACE (4.1) + +// + +Whitespace: [ \t]+ -> channel (HIDDEN); + +Newline: ('\r' '\n'? | '\n') -> channel (HIDDEN); +// + +// COMMENTS (4.1.5) + +// + +LineComment: '--' ~ [\r\n]* -> channel (HIDDEN); + +BlockComment: + ('/*' ('/'* BlockComment | ~ [/*] | '/'+ ~ [/*] | '*'+ ~ [/*])* '*'* '*/') -> channel (HIDDEN) +; + +UnterminatedBlockComment: + '/*' ( + '/'* BlockComment + | // these characters are not part of special sequences in a block comment + ~ [/*] + | // handle / or * characters which are not part of /* or */ and do not appear at the end of the file + ('/'+ ~ [/*] | '*'+ ~ [/*]) + )* + // Handle the case of / or * characters at the end of the file, or a nested unterminated block comment + ('/'+ | '*'+ | '/'* UnterminatedBlockComment)? + // Optional assertion to make sure this rule is working as intended + { + UnterminatedBlockCommentDebugAssert(); + } +; +// + +// META-COMMANDS + +// + +// http://www.postgresql.org/docs/9.3/static/app-psql.html + +MetaCommand: '\\' (~ [\r\n\\"] | '"' ~ [\r\n"]* '"')* ('"' ~ [\r\n"]*)?; + +EndMetaCommand: '\\\\'; +// + +// ERROR + +// + +// Any character which does not match one of the above rules will appear in the token stream as an ErrorCharacter token. + +// This ensures the lexer itself will never encounter a syntax error, so all error handling may be performed by the + +// parser. + +ErrorCharacter: .; + +mode EscapeStringConstantMode; +EscapeStringConstant: EscapeStringText '\'' -> mode (AfterEscapeStringConstantMode); + +UnterminatedEscapeStringConstant: + EscapeStringText + // Handle a final unmatched \ character appearing at the end of the file + '\\'? EOF +; + +fragment EscapeStringText options { + caseInsensitive = false; +}: + ( + '\\\'' + | '\'\'\'' + | '\\' ( + // two-digit hex escapes are still valid when treated as single-digit escapes + 'x' [0-9a-fA-F] + | 'u' [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] + | 'U' [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] + | // Any character other than the Unicode escapes can follow a backslash. Some have special meaning, + // but that doesn't affect the syntax. + ~ [xuU] + ) + | ~ ['\\] + )* +; + +InvalidEscapeStringConstant: InvalidEscapeStringText '\'' -> mode (AfterEscapeStringConstantMode); + +InvalidUnterminatedEscapeStringConstant: + InvalidEscapeStringText + // Handle a final unmatched \ character appearing at the end of the file + '\\'? EOF +; + +fragment InvalidEscapeStringText: ('\'\'' | '\\' . | ~ ['\\])*; + +mode AfterEscapeStringConstantMode; +AfterEscapeStringConstantMode_Whitespace: Whitespace -> type (Whitespace), channel (HIDDEN); + +AfterEscapeStringConstantMode_Newline: + Newline -> type (Newline), channel (HIDDEN), mode (AfterEscapeStringConstantWithNewlineMode) +; + +mode AfterEscapeStringConstantWithNewlineMode; +AfterEscapeStringConstantWithNewlineMode_Whitespace: + Whitespace -> type (Whitespace), channel (HIDDEN) +; + +AfterEscapeStringConstantWithNewlineMode_Newline: Newline -> type (Newline), channel (HIDDEN); + +AfterEscapeStringConstantWithNewlineMode_Continued: + '\'' -> more, mode (EscapeStringConstantMode) +; + +mode DollarQuotedStringMode; +DollarText: + ~ '$'+ + //| '$'([0-9])+ + | // this alternative improves the efficiency of handling $ characters within a dollar-quoted string which are + + // not part of the ending tag. + '$' ~ '$'* +; + +EndDollarStringConstant: ('$' Tag? '$') {isTag()}? {popTag();} -> popMode; diff --git a/headless-services/commons/jpql/grammars/PostgreSqlParser.g4 b/headless-services/commons/jpql/grammars/PostgreSqlParser.g4 index ec078dd6a..065bc6cfe 100644 --- a/headless-services/commons/jpql/grammars/PostgreSqlParser.g4 +++ b/headless-services/commons/jpql/grammars/PostgreSqlParser.g4 @@ -1,1937 +1,5592 @@ -// The MIT License +/* +PostgreSQL grammar. +The MIT License (MIT). +Copyright (c) 2021-2023, Oleksii Kovalov (Oleksii.Kovalov@outlook.com). +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ -// Copyright 2018 Tal Shprecher - -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: - -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. - -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. +// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging parser grammar PostgreSqlParser; -options { tokenVocab=PostgreSqlLexer; } +options { + tokenVocab = PostgreSqlLexer; + superClass = PostgreSqlParserBase; +} +@header { +} + +@members { +} root - : stmt ((SEMI stmt)* SEMI)? EOF + : stmtblock EOF + ; + +plsqlroot + : pl_function + ; + +stmtblock + : stmtmulti + ; + +stmtmulti + : (stmt SEMI?)* ; -// Top Level Description -// TODO: consolidate rollback* into a rollback_stmt a la alter/create/drop stmt - : (abort_stmt - | alter_stmt - | analyze_stmt - | create_stmt - | close_stmt - | cluster_stmt - | comment_stmt - | commit_stmt - | commit_prepared_stmt - | copy_stmt - | deallocate_stmt - | declare_stmt - | delete_stmt - | discard_stmt - | drop_stmt - | execute_stmt - | explain_stmt - | fetch_stmt - | grant_stmt - | import_foreign_schema_stmt - | insert_stmt - | listen_stmt - | load_stmt - | lock_stmt - | move_stmt - | notify_stmt - | prepare_stmt - | prepare_transaction_stmt - | reassign_owned_stmt - | refresh_materialized_view_stmt - | reindex_stmt - | release_savepoint_stmt - | reset_stmt - | revoke_stmt - | rollback_stmt - | rollback_prepared_stmt - | rollback_to_savepoint_stmt - | savepoint_stmt - | security_label_stmt - | select_stmt - | select_into_stmt - | set_stmt - | set_constraints_stmt - | set_role_stmt - | set_session_authorization_stmt - | set_transaction_stmt - | show_stmt - | truncate_stmt - | unlisten_stmt - | update_stmt - | vacuum_stmt - | values_stmt) + : altereventtrigstmt + | altercollationstmt + | alterdatabasestmt + | alterdatabasesetstmt + | alterdefaultprivilegesstmt + | alterdomainstmt + | alterenumstmt + | alterextensionstmt + | alterextensioncontentsstmt + | alterfdwstmt + | alterforeignserverstmt + | alterfunctionstmt + | altergroupstmt + | alterobjectdependsstmt + | alterobjectschemastmt + | alterownerstmt + | alteroperatorstmt + | altertypestmt + | alterpolicystmt + | alterseqstmt + | altersystemstmt + | altertablestmt + | altertblspcstmt + | altercompositetypestmt + | alterpublicationstmt + | alterrolesetstmt + | alterrolestmt + | altersubscriptionstmt + | alterstatsstmt + | altertsconfigurationstmt + | altertsdictionarystmt + | alterusermappingstmt + | analyzestmt + | callstmt + | checkpointstmt + | closeportalstmt + | clusterstmt + | commentstmt + | constraintssetstmt + | copystmt + | createamstmt + | createasstmt + | createassertionstmt + | createcaststmt + | createconversionstmt + | createdomainstmt + | createextensionstmt + | createfdwstmt + | createforeignserverstmt + | createforeigntablestmt + | createfunctionstmt + | creategroupstmt + | creatematviewstmt + | createopclassstmt + | createopfamilystmt + | createpublicationstmt + | alteropfamilystmt + | createpolicystmt + | createplangstmt + | createschemastmt + | createseqstmt + | createstmt + | createsubscriptionstmt + | createstatsstmt + | createtablespacestmt + | createtransformstmt + | createtrigstmt + | createeventtrigstmt + | createrolestmt + | createuserstmt + | createusermappingstmt + | createdbstmt + | deallocatestmt + | declarecursorstmt + | definestmt + | deletestmt + | discardstmt + | dostmt + | dropcaststmt + | dropopclassstmt + | dropopfamilystmt + | dropownedstmt + | dropstmt + | dropsubscriptionstmt + | droptablespacestmt + | droptransformstmt + | droprolestmt + | dropusermappingstmt + | dropdbstmt + | executestmt + | explainstmt + | fetchstmt + | grantstmt + | grantrolestmt + | importforeignschemastmt + | indexstmt + | insertstmt + | mergestmt + | listenstmt + | refreshmatviewstmt + | loadstmt + | lockstmt + | notifystmt + | preparestmt + | reassignownedstmt + | reindexstmt + | removeaggrstmt + | removefuncstmt + | removeoperstmt + | renamestmt + | revokestmt + | revokerolestmt + | rulestmt + | seclabelstmt + | selectstmt + | transactionstmt + | truncatestmt + | unlistenstmt + | updatestmt + | vacuumstmt + | variableresetstmt + | variablesetstmt + | variableshowstmt + | viewstmt + | plsqlconsolecommand ; -abort_stmt - : identifier +plsqlconsolecommand + : MetaCommand EndMetaCommand? ; -alter_stmt - : alter_aggregate_stmt - | alter_collation_stmt - | alter_conversion_stmt - | alter_database_stmt - | alter_default_privileges_stmt - | alter_domain_stmt - | alter_event_trigger_stmt - | alter_extension_stmt - | alter_foreign_data_wrapper_stmt - | alter_foreign_table_stmt - | alter_function_stmt - | alter_group_stmt - | alter_index_stmt - | alter_language_stmt - | alter_large_object_stmt - | alter_materialize_view_stmt - | alter_operator_stmt - | alter_operator_class_stmt - | alter_operator_family_stmt - | alter_policy_stmt - | alter_publication_stmt - | alter_role_stmt - | alter_rule_stmt - | alter_schema_stmt - | alter_sequence_stmt - | alter_server_stmt - | alter_statistics_stmt - | alter_subscription_stmt - | alter_system_stmt - | alter_table_stmt - | alter_tablespace_stmt - | alter_text_search_config_stmt - | alter_text_search_dict_stmt - | alter_text_search_parser_stmt - | alter_text_search_template_stmt - | alter_trigger_stmt - | alter_type_stmt - | alter_user_stmt - | alter_user_mapping_stmt - | alter_view_stmt +callstmt + : CALL func_application ; -alter_aggregate_stmt - : ALTER AGGREGATE name=identifier OPEN_PAREN aggregate_signature CLOSE_PAREN RENAME TO new_name=identifier - | ALTER AGGREGATE name=identifier OPEN_PAREN aggregate_signature CLOSE_PAREN OWNER TO new_owner=role_name - | ALTER AGGREGATE name=identifier OPEN_PAREN aggregate_signature CLOSE_PAREN SET SCHEMA new_schema=identifier +createrolestmt + : CREATE ROLE roleid opt_with optrolelist ; -alter_collation_stmt - : ALTER COLLATION name=name_ REFRESH VERSION - | ALTER COLLATION name=name_ RENAME TO new_name=identifier - | ALTER COLLATION name=name_ OWNER TO new_owner=role_name - | ALTER COLLATION name=name_ SET SCHEMA new_schema=identifier +opt_with + : WITH + //| WITH_LA + | ; -alter_conversion_stmt - : ALTER CONVERSION name=identifier RENAME TO new_name=identifier - | ALTER CONVERSION name=identifier OWNER TO new_owner=role_name - | ALTER CONVERSION name=identifier SET SCHEMA new_schema=identifier +optrolelist + : createoptroleelem* ; -alter_database_stmt - : todo_implement +alteroptrolelist + : alteroptroleelem* ; -alter_default_privileges_stmt - : todo_implement +alteroptroleelem + : PASSWORD (sconst | NULL_P) + | (ENCRYPTED | UNENCRYPTED) PASSWORD sconst + | INHERIT + | CONNECTION LIMIT signediconst + | VALID UNTIL sconst + | USER role_list + | identifier ; -alter_domain_stmt - : ALTER DOMAIN name=identifier (SET DEFAULT expr | DROP DEFAULT) - | ALTER DOMAIN name=identifier (SET|DROP) NOT NULL - | ALTER DOMAIN name=identifier ADD domain_constraint (NOT VALID)? - | ALTER DOMAIN name=identifier DROP CONSTRAINT (IF EXISTS)? constraint_name=identifier (RESTRICT|CASCADE)? - | ALTER DOMAIN name=identifier RENAME CONSTRAINT constraint_name=identifier TO new_constraint_name=identifier - | ALTER DOMAIN name=identifier VALIDATE CONSTRAINT constraint_name=identifier - | ALTER DOMAIN name=identifier OWNER TO new_owner=role_name - | ALTER DOMAIN name=identifier RENAME TO new_name=identifier - | ALTER DOMAIN name=identifier SET SCHEMA new_schema=identifier +createoptroleelem + : alteroptroleelem + | SYSID iconst + | ADMIN role_list + | ROLE role_list + | IN_P (ROLE | GROUP_P) role_list ; -alter_event_trigger_stmt - : ALTER EVENT TRIGGER name=identifier DISABLE - | ALTER EVENT TRIGGER name=identifier ENABLE (REPLICA|ALWAYS)? - | ALTER EVENT TRIGGER name=identifier OWNER TO (new_owner=identifier|CURRENT_USER|SESSION_USER) - | ALTER EVENT TRIGGER name=identifier RENAME TO new_name=identifier +createuserstmt + : CREATE USER roleid opt_with optrolelist ; -alter_extension_stmt - : ALTER EXTENSION name=identifier UPDATE (TO new_version=identifier)? - | ALTER EXTENSION name=identifier SET SCHEMA new_schema=identifier +alterrolestmt + : ALTER (ROLE | USER) rolespec opt_with alteroptrolelist ; -alter_foreign_data_wrapper_stmt - : todo_implement +opt_in_database + : + | IN_P DATABASE name ; -alter_foreign_table_action -// TODO: fix data_type? - : ADD COLUMN? column_name_=column_name data_type_=data_type (COLLATE collation=identifier)? (column_constraints_=column_constraints)? - | DROP COLUMN? (IF EXISTS)? column_name_=column_name (RESTRICT|CASCADE)? - | ALTER COLUMN? column_name_=column_name (SET DATA)? TYPE data_type_=data_type (COLLATE collation=identifier)? - | ALTER COLUMN? column_name_=column_name SET DEFAULT expr - | ALTER COLUMN? column_name_=column_name DROP DEFAULT - | ALTER COLUMN? column_name_=column_name (SET|DROP) NOT NULL - | ALTER COLUMN? column_name_=column_name SET STATISTICS INTEGER - | ALTER COLUMN? column_name_=column_name SET OPEN_PAREN attribute_values=option_list CLOSE_PAREN - | ALTER COLUMN? column_name_=column_name RESET OPEN_PAREN attributes=identifier_list CLOSE_PAREN - | ALTER COLUMN? column_name_=column_name SET STORAGE (PLAIN|EXTERNAL|EXTENDED|MAIN) - | ALTER COLUMN? column_name_=column_name OPTIONS ((ADD|SET|DROP)?) - | ADD table_constraint (NOT VALID)? - | VALIDATE CONSTRAINT constraint_name=todo_fill_in - | DROP CONSTRAINT (IF EXISTS)? constraint_name=todo_fill_in (RESTRICT|CASCADE)? - | DISABLE TRIGGER (trigger_name=todo_fill_in|ALL|USER)? - | ENABLE TRIGGER (trigger_name=todo_fill_in|ALL|USER)? - | ENABLE REPLICA TRIGGER trigger_name=todo_fill_in - | ENABLE ALWAYS TRIGGER trigger_name=todo_fill_in - | SET WITH OIDS +alterrolesetstmt + : ALTER (ROLE | USER) ALL? rolespec opt_in_database setresetclause + ; + +droprolestmt + : DROP (ROLE | USER | GROUP_P) (IF_P EXISTS)? role_list + ; + +creategroupstmt + : CREATE GROUP_P roleid opt_with optrolelist + ; + +altergroupstmt + : ALTER GROUP_P rolespec add_drop USER role_list + ; + +add_drop + : ADD_P + | DROP + ; + +createschemastmt + : CREATE SCHEMA (IF_P NOT EXISTS)? (optschemaname AUTHORIZATION rolespec | colid) optschemaeltlist + ; + +optschemaname + : colid + | + ; + +optschemaeltlist + : schema_stmt* + ; + +schema_stmt + : createstmt + | indexstmt + | createseqstmt + | createtrigstmt + | grantstmt + | viewstmt + ; + +variablesetstmt + : SET (LOCAL | SESSION)? set_rest + ; + +set_rest + : TRANSACTION transaction_mode_list + | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list + | set_rest_more + ; + +generic_set + : var_name (TO | EQUAL) var_list + ; + +set_rest_more + : generic_set + | var_name FROM CURRENT_P + | TIME ZONE zone_value + | CATALOG sconst + | SCHEMA sconst + | NAMES opt_encoding + | ROLE nonreservedword_or_sconst + | SESSION AUTHORIZATION nonreservedword_or_sconst + | XML_P OPTION document_or_content + | TRANSACTION SNAPSHOT sconst + ; + +var_name + : colid (DOT colid)* + ; + +var_list + : var_value (COMMA var_value)* + ; + +var_value + : opt_boolean_or_string + | numericonly + ; + +iso_level + : READ (UNCOMMITTED | COMMITTED) + | REPEATABLE READ + | SERIALIZABLE + ; + +opt_boolean_or_string + : TRUE_P + | FALSE_P + | ON + | nonreservedword_or_sconst + ; + +zone_value + : sconst + | identifier + | constinterval sconst opt_interval + | constinterval OPEN_PAREN iconst CLOSE_PAREN sconst + | numericonly + | DEFAULT + | LOCAL + ; + +opt_encoding + : sconst + | DEFAULT + | + ; + +nonreservedword_or_sconst + : nonreservedword + | sconst + ; + +variableresetstmt + : RESET reset_rest + ; + +reset_rest + : generic_reset + | TIME ZONE + | TRANSACTION ISOLATION LEVEL + | SESSION AUTHORIZATION + ; + +generic_reset + : var_name + | ALL + ; + +setresetclause + : SET set_rest + | variableresetstmt + ; + +functionsetresetclause + : SET set_rest_more + | variableresetstmt + ; + +variableshowstmt + : SHOW (var_name | TIME ZONE | TRANSACTION ISOLATION LEVEL | SESSION AUTHORIZATION | ALL) + ; + +constraintssetstmt + : SET CONSTRAINTS constraints_set_list constraints_set_mode + ; + +constraints_set_list + : ALL + | qualified_name_list + ; + +constraints_set_mode + : DEFERRED + | IMMEDIATE + ; + +checkpointstmt + : CHECKPOINT + ; + +discardstmt + : DISCARD (ALL | TEMP | TEMPORARY | PLANS | SEQUENCES) + ; + +altertablestmt + : ALTER TABLE (IF_P EXISTS)? relation_expr (alter_table_cmds | partition_cmd) + | ALTER TABLE ALL IN_P TABLESPACE name (OWNED BY role_list)? SET TABLESPACE name opt_nowait + | ALTER INDEX (IF_P EXISTS)? qualified_name (alter_table_cmds | index_partition_cmd) + | ALTER INDEX ALL IN_P TABLESPACE name (OWNED BY role_list)? SET TABLESPACE name opt_nowait + | ALTER SEQUENCE (IF_P EXISTS)? qualified_name alter_table_cmds + | ALTER VIEW (IF_P EXISTS)? qualified_name alter_table_cmds + | ALTER MATERIALIZED VIEW (IF_P EXISTS)? qualified_name alter_table_cmds + | ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name (OWNED BY role_list)? SET TABLESPACE name opt_nowait + | ALTER FOREIGN TABLE (IF_P EXISTS)? relation_expr alter_table_cmds + ; + +alter_table_cmds + : alter_table_cmd (COMMA alter_table_cmd)* + ; + +partition_cmd + : ATTACH PARTITION qualified_name partitionboundspec + | DETACH PARTITION qualified_name + ; + +index_partition_cmd + : ATTACH PARTITION qualified_name + ; + +alter_table_cmd + : ADD_P columnDef + | ADD_P IF_P NOT EXISTS columnDef + | ADD_P COLUMN columnDef + | ADD_P COLUMN IF_P NOT EXISTS columnDef + | ALTER opt_column colid alter_column_default + | ALTER opt_column colid DROP NOT NULL_P + | ALTER opt_column colid SET NOT NULL_P + | ALTER opt_column colid DROP EXPRESSION + | ALTER opt_column colid DROP EXPRESSION IF_P EXISTS + | ALTER opt_column colid SET STATISTICS signediconst + | ALTER opt_column iconst SET STATISTICS signediconst + | ALTER opt_column colid SET reloptions + | ALTER opt_column colid RESET reloptions + | ALTER opt_column colid SET STORAGE colid + | ALTER opt_column colid ADD_P GENERATED generated_when AS IDENTITY_P optparenthesizedseqoptlist + | ALTER opt_column colid alter_identity_column_option_list + | ALTER opt_column colid DROP IDENTITY_P + | ALTER opt_column colid DROP IDENTITY_P IF_P EXISTS + | DROP opt_column IF_P EXISTS colid opt_drop_behavior + | DROP opt_column colid opt_drop_behavior + | ALTER opt_column colid opt_set_data TYPE_P typename opt_collate_clause alter_using + | ALTER opt_column colid alter_generic_options + | ADD_P tableconstraint + | ALTER CONSTRAINT name constraintattributespec + | VALIDATE CONSTRAINT name + | DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior + | DROP CONSTRAINT name opt_drop_behavior | SET WITHOUT OIDS - | INHERIT parent_table=identifier - | NO INHERIT parent_table=identifier - | OWNER TO new_owner=role_name - | OPTIONS ((ADD|SET|DROP)?) + | CLUSTER ON name + | SET WITHOUT CLUSTER + | SET LOGGED + | SET UNLOGGED + | ENABLE_P TRIGGER name + | ENABLE_P ALWAYS TRIGGER name + | ENABLE_P REPLICA TRIGGER name + | ENABLE_P TRIGGER ALL + | ENABLE_P TRIGGER USER + | DISABLE_P TRIGGER name + | DISABLE_P TRIGGER ALL + | DISABLE_P TRIGGER USER + | ENABLE_P RULE name + | ENABLE_P ALWAYS RULE name + | ENABLE_P REPLICA RULE name + | DISABLE_P RULE name + | INHERIT qualified_name + | NO INHERIT qualified_name + | OF any_name + | NOT OF + | OWNER TO rolespec + | SET TABLESPACE name + | SET reloptions + | RESET reloptions + | REPLICA IDENTITY_P replica_identity + | ENABLE_P ROW LEVEL SECURITY + | DISABLE_P ROW LEVEL SECURITY + | FORCE ROW LEVEL SECURITY + | NO FORCE ROW LEVEL SECURITY + | alter_generic_options ; -alter_foreign_table_action_list - : alter_foreign_table_action (COMMA alter_foreign_table_action)* +alter_column_default + : SET DEFAULT a_expr + | DROP DEFAULT ; -alter_foreign_table_stmt - : ALTER FOREIGN TABLE (IF EXISTS)? ONLY? name=identifier STAR? actions=alter_foreign_table_action_list - | ALTER FOREIGN TABLE (IF EXISTS)? ONLY? name=identifier STAR? - RENAME COLUMN? column_name_=column_name TO new_column_name=identifier - | ALTER FOREIGN TABLE (IF EXISTS)? name=identifier RENAME TO new_name=identifier - | ALTER FOREIGN TABLE (IF EXISTS)? name=identifier SET SCHEMA new_schama=identifier +opt_drop_behavior + : CASCADE + | RESTRICT + | ; -alter_function_stmt - : todo_implement +opt_collate_clause + : COLLATE any_name + | ; -alter_group_stmt - : ALTER GROUP role=role_name ADD USER users=identifier_list - | ALTER GROUP role=role_name DROP USER users=identifier_list - | ALTER GROUP group_name=identifier RENAME TO new_name=identifier +alter_using + : USING a_expr + | ; -alter_index_stmt - : ALTER INDEX (IF EXISTS)? name=identifier RENAME TO new_name=identifier - | ALTER INDEX (IF EXISTS)? name=identifier SET TABLESPACE tablespace_name=identifier - | ALTER INDEX name=identifier DEPENDS ON EXTENSION extension_name=identifier - | ALTER INDEX (IF EXISTS)? name=identifier SET OPEN_PAREN option_list CLOSE_PAREN - | ALTER INDEX (IF EXISTS)? RESET OPEN_PAREN identifier_list CLOSE_PAREN - | ALTER INDEX ALL IN TABLESPACE name=identifier (OWNED BY roles=identifier_list)? - SET TABLESPACE new_tablespace=identifier NOWAIT? +replica_identity + : NOTHING + | FULL + | DEFAULT + | USING INDEX name ; -alter_language_stmt - : ALTER PROCEDURAL? LANGUAGE name=identifier RENAME TO new_name=identifier - | ALTER PROCEDURAL? LANGUAGE name=identifier OWNER TO (new_owner=identifier|CURRENT_USER|SESSION_USER) +reloptions + : OPEN_PAREN reloption_list CLOSE_PAREN ; -alter_large_object_stmt - : ALTER LARGE OBJECT large_object_oid=INTEGER_LITERAL OWNER TO (new_owner=identifier|CURRENT_USER|SESSION_USER) +opt_reloptions + : WITH reloptions + | ; -alter_materialize_view_stmt - : todo_implement +reloption_list + : reloption_elem (COMMA reloption_elem)* ; -alter_operator_stmt - : todo_implement +reloption_elem + : collabel (EQUAL def_arg | DOT collabel (EQUAL def_arg)?)? ; -alter_operator_class_stmt - : ALTER OPERATOR CLASS name=identifier USING index_method RENAME TO new_name=identifier - | ALTER OPERATOR CLASS name=identifier USING index_method OWNER TO (new_owner=identifier|CURRENT_USER|SESSION_USER) - | ALTER OPERATOR CLASS name=identifier USING index_method SET SCHEMA new_schema=identifier +alter_identity_column_option_list + : alter_identity_column_option+ ; -alter_operator_family_stmt - : todo_implement +alter_identity_column_option + : RESTART (opt_with numericonly)? + | SET (seqoptelem | GENERATED generated_when) ; -alter_policy_stmt - : ALTER POLICY name=identifier ON table_name=identifier RENAME TO new_name=identifier - | ALTER POLICY name=identifier ON table_name=identifier - (TO roles=role_name_list)? - (USING predicate)? - (WITH CHECK predicate)? +partitionboundspec + : FOR VALUES WITH OPEN_PAREN hash_partbound CLOSE_PAREN + | FOR VALUES IN_P OPEN_PAREN expr_list CLOSE_PAREN + | FOR VALUES FROM OPEN_PAREN expr_list CLOSE_PAREN TO OPEN_PAREN expr_list CLOSE_PAREN + | DEFAULT ; -alter_publication_stmt - : ALTER PUBLICATION name=identifier ADD TABLE ONLY? table_names=identifier_list - | ALTER PUBLICATION name=identifier SET TABLE ONLY? table_names=identifier_list - | ALTER PUBLICATION name=identifier DROP TABLE ONLY? table_names=identifier_list - | ALTER PUBLICATION name=identifier SET OPEN_PAREN option_list CLOSE_PAREN - | ALTER PUBLICATION name=identifier OWNER TO new_owner=role_name - | ALTER PUBLICATION name=identifier RENAME TO new_name=name_ +hash_partbound_elem + : nonreservedword iconst ; -alter_role_options - : SUPERUSER | NOSUPERUSER | CREATEDB | NOCREATEDB | CREATEROLE | NOCREATEROLE | - INHERIT | NOINHERIT | LOGIN | NOLOGIN | REPLICATION | NOREPLICATION | BYPASSRLS | - NOBYPASSRLS | CONNECTION LIMIT connlimit=INTEGER | ENCRYPTED? PASSWORD SINGLEQ_STRING_LITERAL | - VALID UNTIL SINGLEQ_STRING_LITERAL +hash_partbound + : hash_partbound_elem (COMMA hash_partbound_elem)* ; -alter_role_stmt - : ALTER ROLE role=role_name WITH? options=alter_role_options+ - | ALTER ROLE name=name_ RENAME TO new_name=name_ - | ALTER ROLE (role=role_name | ALL) (IN DATABASE database_name=name_)? SET configuration_parameter=identifier (TO | EQUAL) (value=param_value | DEFAULT) - | ALTER ROLE (role=role_name | ALL) (IN DATABASE database_name=name_)? SET configuration_parameter=identifier FROM CURRENT - | ALTER ROLE (role=role_name | ALL) (IN DATABASE database_name=name_)? RESET configuration_parameter=identifier - | ALTER ROLE (role=role_name | ALL) (IN DATABASE database_name=name_)? RESET ALL +altercompositetypestmt + : ALTER TYPE_P any_name alter_type_cmds ; -alter_rule_stmt - : ALTER RULE name=name_ ON table_name=identifier RENAME TO new_name=name_ +alter_type_cmds + : alter_type_cmd (COMMA alter_type_cmd)* ; -alter_schema_stmt - : ALTER SCHEMA name=identifier RENAME TO new_name=identifier - | ALTER SCHEMA name=identifier OWNER TO (new_owner=identifier|CURRENT_USER|SESSION_USER) +alter_type_cmd + : ADD_P ATTRIBUTE tablefuncelement opt_drop_behavior + | DROP ATTRIBUTE (IF_P EXISTS)? colid opt_drop_behavior + | ALTER ATTRIBUTE colid opt_set_data TYPE_P typename opt_collate_clause opt_drop_behavior ; -alter_sequence_stmt - : ALTER SEQUENCE (IF EXISTS)? name=name_ +closeportalstmt + : CLOSE (cursor_name | ALL) ; -alter_server_options_list - : ((ADD|SET|DROP)? option=identifier (value=param_value)?) - (COMMA (ADD|SET|DROP)? option=identifier (value=param_value)?)* +copystmt + : COPY opt_binary qualified_name opt_column_list copy_from opt_program copy_file_name copy_delimiter opt_with copy_options where_clause + | COPY OPEN_PAREN preparablestmt CLOSE_PAREN TO opt_program copy_file_name opt_with copy_options ; -alter_server_stmt - : ALTER SERVER name=identifier ( - (VERSION SINGLEQ_STRING_LITERAL) | - ((VERSION SINGLEQ_STRING_LITERAL)? (OPTIONS OPEN_PAREN alter_server_options_list CLOSE_PAREN))) - | ALTER SERVER name=identifier OWNER TO new_owner=role_name - | ALTER SERVER name=identifier RENAME TO new_name=name_ +copy_from + : FROM + | TO ; -alter_statistics_stmt - : ALTER STATISTICS name=identifier OWNER TO (new_owner=identifier|CURRENT_USER|SESSION_USER) - | ALTER STATISTICS name=identifier RENAME TO new_name=identifier - | ALTER STATISTICS name=identifier SET SCHEMA new_schema=identifier +opt_program + : PROGRAM + | ; -alter_subscription_stmt - : ALTER SUBSCRIPTION name=identifier CONNECTION conninfo=param_value - | ALTER SUBSCRIPTION name=identifier SET PUBLICATION publication_name=name_list - (WITH OPEN_PAREN option_list CLOSE_PAREN)? - | ALTER SUBSCRIPTION name=identifier REFRESH PUBLICATION (WITH OPEN_PAREN option_list CLOSE_PAREN)? - | ALTER SUBSCRIPTION name=identifier ENABLE - | ALTER SUBSCRIPTION name=identifier DISABLE - | ALTER SUBSCRIPTION name=identifier SET OPEN_PAREN option_list CLOSE_PAREN - | ALTER SUBSCRIPTION name=identifier OWNER TO new_owner=role_name - | ALTER SUBSCRIPTION name=identifier RENAME TO new_name=identifier +copy_file_name + : sconst + | STDIN + | STDOUT ; -alter_system_stmt - : ALTER SYSTEM SET param=IDENTIFIER (TO|EQUAL) value=param_value - | ALTER SYSTEM RESET param=IDENTIFIER - | ALTER SYSTEM RESET ALL +copy_options + : copy_opt_list + | OPEN_PAREN copy_generic_opt_list CLOSE_PAREN ; -alter_table_stmt - : todo_implement +copy_opt_list + : copy_opt_item* ; -alter_tablespace_stmt - : ALTER TABLESPACE name=identifier RENAME TO new_name=identifier - | ALTER TABLESPACE name=identifier OWNER TO (new_owner=identifier|CURRENT_USER|SESSION_USER) - | ALTER TABLESPACE name=identifier SET OPEN_PAREN option_list CLOSE_PAREN - | ALTER TABLESPACE name=identifier RESET OPEN_PAREN identifier_list CLOSE_PAREN +copy_opt_item + : BINARY + | FREEZE + | DELIMITER opt_as sconst + | NULL_P opt_as sconst + | CSV + | HEADER_P + | QUOTE opt_as sconst + | ESCAPE opt_as sconst + | FORCE QUOTE columnlist + | FORCE QUOTE STAR + | FORCE NOT NULL_P columnlist + | FORCE NULL_P columnlist + | ENCODING sconst ; -alter_text_search_config_stmt - : ALTER TEXT SEARCH CONFIGURATION name=identifier - ADD MAPPING FOR token_types=identifier_list WITH dictionary_names=identifier_list - | ALTER TEXT SEARCH CONFIGURATION name=identifier - ALTER MAPPING FOR token_types=identifier_list WITH dictionary_names=identifier_list - | ALTER TEXT SEARCH CONFIGURATION name=identifier - ALTER MAPPING REPLACE old_dictionary=identifier WITH new_dictionary=identifier - | ALTER TEXT SEARCH CONFIGURATION name=identifier - ALTER MAPPING FOR token_types=identifier_list REPLACE old_dictionary=identifier WITH new_dictionary=identifier - | ALTER TEXT SEARCH CONFIGURATION name=identifier - DROP MAPPING (IF EXISTS)? FOR token_types=identifier_list - | ALTER TEXT SEARCH CONFIGURATION name=identifier RENAME TO new_name=identifier - | ALTER TEXT SEARCH CONFIGURATION name=identifier OWNER TO new_owner=role_name - | ALTER TEXT SEARCH CONFIGURATION name=identifier SET SCHEMA new_schema=identifier +opt_binary + : BINARY + | ; -alter_text_search_dict_stmt - : todo_implement +copy_delimiter + : opt_using DELIMITERS sconst + | ; -alter_text_search_parser_stmt - : todo_implement +opt_using + : USING + | ; -alter_text_search_template_stmt - : ALTER TEXT SEARCH TEMPLATE name=identifier RENAME TO new_name=identifier - | ALTER TEXT SEARCH TEMPLATE name=identifier SET SCHEMA new_schema=identifier +copy_generic_opt_list + : copy_generic_opt_elem (COMMA copy_generic_opt_elem)* ; -alter_trigger_stmt - : ALTER TRIGGER name=identifier ON table_name=identifier RENAME TO new_name=identifier - | ALTER TRIGGER name=identifier ON table_name=identifier DEPENDS ON EXTENSION extension_name=identifier +copy_generic_opt_elem + : collabel copy_generic_opt_arg ; -alter_type_stmt - : todo_implement +copy_generic_opt_arg + : opt_boolean_or_string + | numericonly + | STAR + | OPEN_PAREN copy_generic_opt_arg_list CLOSE_PAREN + | ; -alter_user_stmt - : todo_implement +copy_generic_opt_arg_list + : copy_generic_opt_arg_list_item (COMMA copy_generic_opt_arg_list_item)* ; -alter_user_mapping_stmt - : ALTER USER MAPPING FOR user=role_name - SERVER server_name=identifier - OPTIONS (OPEN_PAREN alter_server_options_list CLOSE_PAREN) +copy_generic_opt_arg_list_item + : opt_boolean_or_string ; -alter_view_stmt - : todo_implement +createstmt + : CREATE opttemp TABLE (IF_P NOT EXISTS)? qualified_name ( + OPEN_PAREN opttableelementlist CLOSE_PAREN optinherit optpartitionspec table_access_method_clause optwith oncommitoption opttablespace + | OF any_name opttypedtableelementlist optpartitionspec table_access_method_clause optwith oncommitoption opttablespace + | PARTITION OF qualified_name opttypedtableelementlist partitionboundspec optpartitionspec table_access_method_clause optwith oncommitoption + opttablespace + ) ; -analyze_stmt - : ANALYZE VERBOSE? table_name_ (OPEN_PAREN name_list CLOSE_PAREN)? - ; - -close_stmt - : todo_implement - ; - -cluster_stmt - : todo_implement - ; - -comment_stmt - : todo_implement - ; - -commit_stmt - : todo_implement - ; - -commit_prepared_stmt - : todo_implement - ; - -copy_stmt - : todo_implement - ; - -create_stmt - : create_access_method_stmt - | create_aggregate_stmt - | create_cast_stmt - | create_collation_stmt - | create_conversion_stmt - | create_database_stmt - | create_domain_stmt - | create_event_trigger_stmt - | create_foreign_data_stmt - | create_foreign_table_stmt - | create_function_stmt - | create_group_stmt - | create_index_stmt - | create_language_stmt - | create_materialized_view_stmt - | create_operator_stmt - | create_operator_class_stmt - | create_operator_family_stmt - | create_policy_stmt - | create_role_stmt - | create_rule_stmt - | create_schema_stmt - | create_sequence_stmt - | create_server_stmt - | create_statistics_stmt - | create_subscription_stmt - | create_table_stmt - | create_table_as_stmt - | create_tablespace_stmt - | create_text_search_config_stmt - | create_text_search_dict_stmt - | create_text_search_parser_stmt - | create_text_search_template_stmt - | create_transform_stmt - | create_trigger_stmt - | create_type_stmt - | create_user_stmt - | create_user_mapping_stmt - | create_view_stmt - ; - -create_access_method_stmt - : CREATE ACCESS METHOD name_ TYPE INDEX HANDLER name_; - -create_aggregate_stmt - : (CREATE AGGREGATE name_ OPEN_PAREN (IN | VARIADIC)? name_? data_type_list CLOSE_PAREN - OPEN_PAREN - SFUNC EQUAL identifier COMMA - STYPE EQUAL identifier - (COMMA SSPACE EQUAL INTEGER_LITERAL)? - (COMMA FINALFUNC EQUAL identifier)? - (COMMA FINALFUNC_EXTRA)? - (COMMA COMBINEFUNC EQUAL identifier)? - (COMMA SERIALFUNC EQUAL identifier)? - (COMMA DESERIALFUNC EQUAL identifier)? - (COMMA INITCOND EQUAL expr)? - (COMMA MSFUNC EQUAL identifier)? - (COMMA MINVFUNC EQUAL identifier)? - (COMMA MSTYPE EQUAL identifier)? - (COMMA MSSPACE EQUAL INTEGER_LITERAL)? - (COMMA MFINALFUNC EQUAL identifier)? - (COMMA MFINALFUNC_EXTRA)? - (COMMA MINITCOND EQUAL identifier)? - (COMMA SORTOP EQUAL identifier)? - (COMMA PARALLEL EQUAL (SAFE | RESTRICTED | UNSAFE))? - CLOSE_PAREN) - | (CREATE AGGREGATE name_ OPEN_PAREN ((IN | VARIADIC)? name_? data_type_list)? - ORDER BY (IN | VARIADIC)? name_? data_type_list CLOSE_PAREN - OPEN_PAREN - SFUNC EQUAL identifier COMMA - STYPE EQUAL identifier - (COMMA SSPACE EQUAL INTEGER_LITERAL)? - (COMMA FINALFUNC EQUAL identifier)? - (COMMA FINALFUNC_EXTRA)? - (COMMA INITCOND EQUAL expr)? - (COMMA PARALLEL EQUAL (SAFE | RESTRICTED | UNSAFE))? - (COMMA HYPOTHETICAL)? - CLOSE_PAREN) - | (CREATE AGGREGATE name_ - OPEN_PAREN - BASETYPE EQUAL data_type COMMA - SFUNC EQUAL identifier COMMA - STYPE EQUAL identifier - (COMMA SSPACE EQUAL INTEGER_LITERAL)? - (COMMA FINALFUNC EQUAL identifier)? - (COMMA FINALFUNC_EXTRA)? - (COMMA COMBINEFUNC EQUAL identifier)? - (COMMA SERIALFUNC EQUAL identifier)? - (COMMA DESERIALFUNC EQUAL identifier)? - (COMMA INITCOND EQUAL expr)? - (COMMA MSFUNC EQUAL identifier)? - (COMMA MINVFUNC EQUAL identifier)? - (COMMA MSTYPE EQUAL identifier)? - (COMMA MSSPACE EQUAL INTEGER_LITERAL)? - (COMMA MFINALFUNC EQUAL identifier)? - (COMMA MFINALFUNC_EXTRA)? - (COMMA MINITCOND EQUAL identifier)? - (COMMA SORTOP EQUAL identifier)? - CLOSE_PAREN) - ; - -create_cast_stmt - : CREATE CAST OPEN_PAREN data_type AS data_type CLOSE_PAREN - ((WITH FUNCTION identifier ( OPEN_PAREN data_type_list CLOSE_PAREN )?) - | (WITHOUT FUNCTION) - | (WITH INOUT)) - (AS ASSIGNMENT | AS IMPLICIT)? - ; - -create_collation_opt - : LOCALE EQUAL expr - | LC_COLLATE EQUAL expr - | LC_CTYPE EQUAL expr - | PROVIDER EQUAL expr - | VERSION EQUAL expr - | DOUBLEQ_STRING_LITERAL EQUAL expr - ; - -create_collation_opt_list - : create_collation_opt (COMMA create_collation_opt)* - ; - -create_collation_stmt - : (CREATE COLLATION (IF NOT EXISTS)? name_ OPEN_PAREN - create_collation_opt_list CLOSE_PAREN) - | (CREATE COLLATION (IF NOT EXISTS)? name_ FROM name_) - ; - -create_conversion_stmt - : CREATE DEFAULT? CONVERSION identifier - FOR SINGLEQ_STRING_LITERAL TO SINGLEQ_STRING_LITERAL FROM name_ - ; - -create_database_stmt - : CREATE DATABASE name_ - ( WITH? - (OWNER EQUAL name_)? - (TEMPLATE EQUAL name_)? - (ENCODING EQUAL name_)? - (LC_COLLATE EQUAL name_)? - (LC_CTYPE EQUAL name_)? - (TABLESPACE EQUAL name_)? - (ALLOW_CONNECTIONS EQUAL name_)? - (CONNECTION LIMIT EQUAL parameterOrIntegerLiteral)? - (IS_TEMPLATE EQUAL parameterOrIntegerLiteral)? - ) - ; - -domain_constraint - : (CONSTRAINT name_)? ( NOT NULL | NULL | CHECK OPEN_PAREN expr CLOSE_PAREN ) - ; - -create_domain_stmt - : CREATE DOMAIN name_ AS? data_type - ((COLLATE name_) | - (DEFAULT expr) | - domain_constraint)* - ; - -create_event_trigger_cond - : filter_stmt=identifier IN OPEN_PAREN SINGLEQ_STRING_LITERAL (COMMA SINGLEQ_STRING_LITERAL)* CLOSE_PAREN - (AND create_event_trigger_cond)* - ; - -create_event_trigger_stmt - : CREATE EVENT TRIGGER trigger=identifier ON event=identifier - (WHEN create_event_trigger_cond)? - EXECUTE PROCEDURE fn_name=identifier OPEN_PAREN CLOSE_PAREN - ; - -// TODO: rename to options_list? -create_foreign_data_options - : opt=name_ SINGLEQ_STRING_LITERAL - (COMMA create_foreign_data_options)* - ; - -create_foreign_data_stmt - : CREATE FOREIGN DATA WRAPPER wrapper=identifier - (HANDLER handler=identifier | NO HANDLER)* - (VALIDATOR validator=identifier | NO VALIDATOR)? - (OPTIONS OPEN_PAREN opts=create_foreign_data_options CLOSE_PAREN)? - ; - -create_foreign_table_stmt - : CREATE FOREIGN TABLE (IF NOT EXISTS)? table_name_TODO=identifier - OPEN_PAREN column_name_TODO=identifier column_type=identifier - (OPTIONS OPEN_PAREN opts=create_foreign_data_options CLOSE_PAREN)? - (COLLATE create_collation_opt)? - CLOSE_PAREN - (INHERITS name_list)? - SERVER server_name=name_ - (OPTIONS OPEN_PAREN opts=create_foreign_data_options CLOSE_PAREN)? - ; - -create_function_stmt - : CREATE (OR REPLACE)? FUNCTION fn_name=name_ - ; - -create_group_stmt - : CREATE GROUP group=identifier - (WITH? - (SUPERUSER | NOSUPERUSER | CREATEDB | NOCREATEDB | - CREATEROLE | NOCREATEROLE | CREATEUSER | NOCREATEUSER | - INHERIT | NOINHERIT | LOGIN | NOLOGIN | - (ENCRYPTED | UNENCRYPTED)? PASSWORD (SINGLEQ_STRING_LITERAL | NULL) | - VALID UNTIL SINGLEQ_STRING_LITERAL | IN ROLE name_list | IN GROUP name_list | ROLE name_list | - ADMIN name_list | USER name_list | SYSID INTEGER_LITERAL)+)? - ; - -create_index_stmt - : CREATE UNIQUE? INDEX CONCURRENTLY? ((IF NOT EXISTS)? index_name=identifier)? - ON tableName=identifier (USING index_method)? - (TABLESPACE tablespace_name=identifier)? - (WHERE predicate)? - ; - -create_language_stmt - : (CREATE (OR REPLACE)? PROCEDURAL? LANGUAGE language_name=identifier) | - (CREATE (OR REPLACE)? TRUSTED? PROCEDURAL? LANGUAGE language_name=identifier - HANDLER call_handler=identifier (INLINE inline_handler=identifier)? (VALIDATOR valfunction=identifier)?) - ; - -// TODO: normalize aliases so we don't have tableName and table_name -create_materialized_view_stmt - : CREATE MATERIALIZED VIEW (IF NOT EXISTS)? tableName=identifier - (OPEN_PAREN columns=identifier_list CLOSE_PAREN)? - (WITH /* todo: implement */)? - (TABLESPACE tablespace_name=identifier)? - AS query=select_stmt - (WITH NO? DATA)? - ; - -// TODO: this one is tricky because of the yet undefined 'operator' lexeme -create_operator_stmt - : CREATE OPERATOR opName=identifier - OPEN_PAREN - PROCEDURE EQUAL function_name=identifier - (COMMA LEFTARG EQUAL left_type=name_)? - (COMMA RIGHTARG EQUAL right_type=name_)? - (COMMA COMMUTATOR EQUAL com_op=name_)? - (COMMA NEGATOR EQUAL neg_op=name_)? - (COMMA RESTRICT EQUAL res_proc=name_)? - (COMMA JOIN EQUAL join_proc=name_)? - (COMMA HASHES)? - (COMMA MERGES)? - CLOSE_PAREN - ; - -create_operator_class_opt - : (OPERATOR strategy_number=INTEGER_LITERAL opName=identifier (OPEN_PAREN identifier COMMA identifier CLOSE_PAREN)?) | - (FUNCTION support_number=INTEGER_LITERAL (OPEN_PAREN identifier (COMMA identifier)? CLOSE_PAREN)? func_name_=identifier OPEN_PAREN data_type_list CLOSE_PAREN) | - (STORAGE storage_type=identifier) - ; - -create_operator_class_stmt - : CREATE OPERATOR CLASS name=identifier DEFAULT? FOR TYPE op_type=identifier - USING index_method (FAMILY family_name=identifier)? AS - create_operator_class_opt (COMMA create_operator_class_opt)* - ; - -create_operator_family_stmt - : CREATE OPERATOR FAMILY name=identifier USING index_method - ; - -create_policy_stmt - : CREATE POLICY name=identifier ON tableName=identifier - (FOR (ALL | SELECT | INSERT | UPDATE | DELETE))? - (TO role=role_name)? // TODO: make a list here - (USING OPEN_PAREN predicate CLOSE_PAREN)? - (WITH CHECK OPEN_PAREN predicate CLOSE_PAREN)? - ; - -create_role_stmt - : CREATE ROLE role=role_name - (WITH? - (SUPERUSER | NOSUPERUSER | CREATEDB | NOCREATEDB | - CREATEROLE | NOCREATEROLE | INHERIT | NOINHERIT | LOGIN | NOLOGIN | - REPLICATION | NOREPLICATION | BYPASSRLS | NOBYPASSRLS | - CONNECTION LIMIT parameterOrIntegerLiteral | ENCRYPTED? PASSWORD (SINGLEQ_STRING_LITERAL | NULL) | - VALID UNTIL SINGLEQ_STRING_LITERAL | IN ROLE name_list | IN GROUP name_list | ROLE name_list | - ADMIN name_list | USER name_list | SYSID INTEGER_LITERAL)+)? +opttemp + : TEMPORARY + | TEMP + | LOCAL (TEMPORARY | TEMP) + | GLOBAL (TEMPORARY | TEMP) + | UNLOGGED + | ; -create_rule_event - : SELECT | INSERT | UPDATE | DELETE +opttableelementlist + : tableelementlist + | ; -// TODO: resolve 'command' to its proper definition -create_rule_stmt - : CREATE (OR REPLACE)? RULE name=name_ AS ON event=create_rule_event - TO tableName=identifier (WHERE predicate)? - DO (ALSO | INSTEAD)? (NOTHING | command=identifier) +opttypedtableelementlist + : OPEN_PAREN typedtableelementlist CLOSE_PAREN + | ; -create_schema_stmt - : (CREATE SCHEMA schema_name=identifier (AUTHORIZATION role_name)? todo_fill_in? ) | - (CREATE SCHEMA AUTHORIZATION role_name todo_fill_in?) | - (CREATE SCHEMA IF NOT EXISTS schema_name=identifier (AUTHORIZATION role_name)?) | - (CREATE SCHEMA IF NOT EXISTS AUTHORIZATION role_name) +tableelementlist + : tableelement (COMMA tableelement)* ; -create_sequence_stmt - : CREATE (TEMPORARY | TEMP)? SEQUENCE (IF NOT EXISTS)? name=identifier (INCREMENT BY? increment=parameterOrIntegerLiteral)? - (MINVALUE minvalue=parameterOrIntegerLiteral | NO MINVALUE)? - (MAXVALUE maxvalue=parameterOrIntegerLiteral | NO MAXVALUE)? - (START WITH? start=parameterOrIntegerLiteral)? (CACHE cache=parameterOrIntegerLiteral)? (NO? CYCLE)? - (OWNED BY ((table_name=identifier DOT column_name_=identifier) | NONE))? +typedtableelementlist + : typedtableelement (COMMA typedtableelement)* ; -create_server_stmt - : todo_implement +tableelement + : tableconstraint + | tablelikeclause + | columnDef ; -create_statistics_stmt - : todo_implement +typedtableelement + : columnOptions + | tableconstraint ; -create_subscription_stmt - : todo_implement +columnDef + : colid typename create_generic_options colquallist ; -create_table_stmt - : todo_implement +columnOptions + : colid (WITH OPTIONS)? colquallist ; -create_table_as_stmt - : todo_implement +colquallist + : colconstraint* ; -create_tablespace_stmt - : todo_implement +colconstraint + : CONSTRAINT name colconstraintelem + | colconstraintelem + | constraintattr + | COLLATE any_name ; -create_text_search_config_stmt - : todo_implement +colconstraintelem + : NOT NULL_P + | NULL_P + | UNIQUE opt_definition optconstablespace + | PRIMARY KEY opt_definition optconstablespace + | CHECK OPEN_PAREN a_expr CLOSE_PAREN opt_no_inherit + | DEFAULT b_expr + | GENERATED generated_when AS ( + IDENTITY_P optparenthesizedseqoptlist + | OPEN_PAREN a_expr CLOSE_PAREN STORED + ) + | REFERENCES qualified_name opt_column_list key_match key_actions ; -create_text_search_dict_stmt - : todo_implement +generated_when + : ALWAYS + | BY DEFAULT ; -create_text_search_parser_stmt - : todo_implement +constraintattr + : DEFERRABLE + | NOT DEFERRABLE + | INITIALLY (DEFERRED | IMMEDIATE) ; -create_text_search_template_stmt - : todo_implement +tablelikeclause + : LIKE qualified_name tablelikeoptionlist ; -create_transform_stmt - : todo_implement - ; - -create_trigger_stmt - : todo_implement - ; - -create_type_stmt - : todo_implement - ; - -create_user_stmt - : todo_implement - ; - -create_user_mapping_stmt - : todo_implement - ; - -create_view_stmt - : CREATE (OR REPLACE)? (TEMP|TEMPORARY)? RECURSIVE? VIEW name=name_ (OPEN_PAREN name_list CLOSE_PAREN)? - (WITH OPEN_PAREN option_list CLOSE_PAREN)? - AS (select_stmt | values_stmt) - (WITH (CASCADED|LOCAL)? CHECK OPTION)? - ; - -deallocate_stmt - : todo_implement - ; - -declare_stmt - : todo_implement - ; - -delete_stmt - : with_clause? - DELETE FROM ONLY? table_name_ STAR? (AS? alias)? - (USING identifier_list)? - (where_clause | (WHERE CURRENT OF cursor_name_=identifier))? - returning_clause? - ; - -discard_stmt - : DISCARD (ALL | PLANS | SEQUENCES | TEMPORARY | TEMP) - ; - -drop_stmt - : drop_access_method_stmt - | drop_aggregate_stmt - | drop_cast_stmt - | drop_collation_stmt - | drop_conversion_stmt - | drop_database_stmt - | drop_domain_stmt - | drop_event_trigger_stmt - | drop_extension_stmt - | drop_foreign_data_wrapper_stmt - | drop_foreign_table_stmt - | drop_function_stmt - | drop_group_stmt - | drop_index_stmt - | drop_language_stmt - | drop_materialized_view_stmt - | drop_operator_stmt - | drop_operator_class_stmt - | drop_operator_family_stmt - | drop_owned_stmt - | drop_policy_stmt - | drop_publication_stmt - | drop_role_stmt - | drop_rule_stmt - | drop_schema_stmt - | drop_sequence_stmt - | drop_server_stmt - | drop_statistics_stmt - | drop_subscription_stmt - | drop_table_stmt - | drop_tablespace_stmt - | drop_text_search_config_stmt - | drop_text_search_dict_stmt - | drop_text_search_parser_stmt - | drop_text_search_template_stmt - | drop_transform_stmt - | drop_trigger_stmt - | drop_type_stmt - | drop_user_stmt - | drop_user_mapping_stmt - | drop_view_stmt - ; - - -drop_access_method_stmt - : DROP ACCESS METHOD (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +tablelikeoptionlist + : ((INCLUDING | EXCLUDING) tablelikeoption)* ; -drop_aggregate_stmt - : DROP AGGREGATE (IF EXISTS)? name=identifier OPEN_PAREN aggregate_signature CLOSE_PAREN +tablelikeoption + : COMMENTS + | CONSTRAINTS + | DEFAULTS + | IDENTITY_P + | GENERATED + | INDEXES + | STATISTICS + | STORAGE + | ALL ; -drop_cast_stmt - : DROP CAST (IF EXISTS)? OPEN_PAREN source_type=data_type AS target_type=identifier CLOSE_PAREN (CASCADE|RESTRICT)? +tableconstraint + : CONSTRAINT name constraintelem + | constraintelem ; -drop_collation_stmt - : DROP COLLATION (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +constraintelem + : CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec + | UNIQUE ( + OPEN_PAREN columnlist CLOSE_PAREN opt_c_include opt_definition optconstablespace constraintattributespec + | existingindex constraintattributespec + ) + | PRIMARY KEY ( + OPEN_PAREN columnlist CLOSE_PAREN opt_c_include opt_definition optconstablespace constraintattributespec + | existingindex constraintattributespec + ) + | EXCLUDE access_method_clause OPEN_PAREN exclusionconstraintlist CLOSE_PAREN opt_c_include opt_definition optconstablespace exclusionwhereclause + constraintattributespec + | FOREIGN KEY OPEN_PAREN columnlist CLOSE_PAREN REFERENCES qualified_name opt_column_list key_match key_actions constraintattributespec ; -drop_conversion_stmt - : DROP CONVERSION (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +opt_no_inherit + : NO INHERIT + | ; -drop_database_stmt - : DROP DATABASE (IF EXISTS)? name=identifier +opt_column_list + : OPEN_PAREN columnlist CLOSE_PAREN + | ; -drop_domain_stmt - : DROP DOMAIN (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +columnlist + : columnElem (COMMA columnElem)* ; -drop_event_trigger_stmt - : DROP EVENT TRIGGER (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +columnElem + : colid ; -drop_extension_stmt - : DROP EXTENSION (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +opt_c_include + : INCLUDE OPEN_PAREN columnlist CLOSE_PAREN + | ; -drop_foreign_data_wrapper_stmt - : DROP FOREIGN DATA WRAPPER (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +key_match + : MATCH (FULL | PARTIAL | SIMPLE) + | ; -drop_foreign_table_stmt - : DROP FOREIGN TABLE (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +exclusionconstraintlist + : exclusionconstraintelem (COMMA exclusionconstraintelem)* ; -drop_function_stmt - : DROP FUNCTION (IF EXISTS)? functions=func_sig_list (CASCADE|RESTRICT)? +exclusionconstraintelem + : index_elem WITH (any_operator | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN) ; -drop_group_stmt - : DROP GROUP (IF EXISTS)? names=identifier_list +exclusionwhereclause + : WHERE OPEN_PAREN a_expr CLOSE_PAREN + | ; -drop_index_stmt - : DROP INDEX CONCURRENTLY? (IF EXISTS)? names=name_list (CASCADE|RESTRICT)? +key_actions + : key_update + | key_delete + | key_update key_delete + | key_delete key_update + | ; -drop_language_stmt - : DROP PROCEDURAL? LANGUAGE (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +key_update + : ON UPDATE key_action ; -drop_materialized_view_stmt - : DROP MATERIALIZED VIEW (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +key_delete + : ON DELETE_P key_action ; -drop_operator_stmt - : todo_implement +key_action + : NO ACTION + | RESTRICT + | CASCADE + | SET (NULL_P | DEFAULT) ; -drop_operator_class_stmt - : DROP OPERATOR CLASS (IF EXISTS)? name=identifier USING index_method (CASCADE|RESTRICT)? +optinherit + : INHERITS OPEN_PAREN qualified_name_list CLOSE_PAREN + | ; -drop_operator_family_stmt - : DROP OPERATOR FAMILY (IF EXISTS)? name=identifier USING index_method (CASCADE|RESTRICT)? +optpartitionspec + : partitionspec + | ; -drop_owned_stmt - : DROP OWNED BY role_name_list (CASCADE|RESTRICT)? +partitionspec + : PARTITION BY colid OPEN_PAREN part_params CLOSE_PAREN ; -drop_policy_stmt - : DROP POLICY (IF EXISTS)? name=identifier ON table_name=identifier (CASCADE|RESTRICT)? +part_params + : part_elem (COMMA part_elem)* ; -drop_publication_stmt - : DROP PUBLICATION (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +part_elem + : colid opt_collate opt_class + | func_expr_windowless opt_collate opt_class + | OPEN_PAREN a_expr CLOSE_PAREN opt_collate opt_class ; -drop_role_stmt - : DROP ROLE (IF EXISTS)? names=identifier_list +table_access_method_clause + : USING name + | ; -drop_rule_stmt - : DROP RULE (IF EXISTS)? name=name_ ON table_name=identifier (CASCADE|RESTRICT)? +optwith + : WITH reloptions + | WITHOUT OIDS + | ; -drop_schema_stmt - : DROP SCHEMA (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +oncommitoption + : ON COMMIT (DROP | DELETE_P ROWS | PRESERVE ROWS) + | ; -drop_sequence_stmt - : DROP SEQUENCE (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +opttablespace + : TABLESPACE name + | ; -drop_server_stmt - : DROP SERVER (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +optconstablespace + : USING INDEX TABLESPACE name + | ; -drop_statistics_stmt - : DROP STATISTICS (IF EXISTS)? names=identifier_list +existingindex + : USING INDEX name ; -drop_subscription_stmt - : DROP SUBSCRIPTION (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +createstatsstmt + : CREATE STATISTICS (IF_P NOT EXISTS)? any_name opt_name_list ON expr_list FROM from_list ; -drop_table_stmt - : DROP TABLE (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +alterstatsstmt + : ALTER STATISTICS (IF_P EXISTS)? any_name SET STATISTICS signediconst ; -drop_tablespace_stmt - : DROP TABLESPACE (IF EXISTS)? name=identifier +createasstmt + : CREATE opttemp TABLE (IF_P NOT EXISTS)? create_as_target AS selectstmt opt_with_data ; -drop_text_search_config_stmt - : DROP TEXT SEARCH CONFIGURATION (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +create_as_target + : qualified_name opt_column_list table_access_method_clause optwith oncommitoption opttablespace ; -drop_text_search_dict_stmt - : DROP TEXT SEARCH DICTIONARY (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +opt_with_data + : WITH (DATA_P | NO DATA_P) + | ; -drop_text_search_parser_stmt - : DROP TEXT SEARCH PARSER (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +creatematviewstmt + : CREATE optnolog MATERIALIZED VIEW (IF_P NOT EXISTS)? create_mv_target AS selectstmt opt_with_data ; -drop_text_search_template_stmt - : DROP TEXT SEARCH TEMPLATE (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? +create_mv_target + : qualified_name opt_column_list table_access_method_clause opt_reloptions opttablespace ; -drop_transform_stmt - : DROP TRANSFORM (IF EXISTS)? FOR type_name_=identifier LANGUAGE lang_name=identifier (CASCADE|RESTRICT) +optnolog + : UNLOGGED + | ; -drop_trigger_stmt - : DROP TRIGGER (IF EXISTS)? name=identifier ON table_name=identifier (CASCADE|RESTRICT)? +refreshmatviewstmt + : REFRESH MATERIALIZED VIEW opt_concurrently qualified_name opt_with_data ; -drop_type_stmt - : DROP TYPE (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +createseqstmt + : CREATE opttemp SEQUENCE (IF_P NOT EXISTS)? qualified_name optseqoptlist ; -drop_user_stmt - : DROP USER (IF EXISTS)? names=identifier_list +alterseqstmt + : ALTER SEQUENCE (IF_P EXISTS)? qualified_name seqoptlist ; -drop_user_mapping_stmt - : DROP USER MAPPING (IF EXISTS)? FOR (user_name=name_|USER|CURRENT_USER|SESSION_USER|PUBLIC) SERVER server_name=identifier +optseqoptlist + : seqoptlist + | ; -drop_view_stmt - : DROP VIEW (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? +optparenthesizedseqoptlist + : OPEN_PAREN seqoptlist CLOSE_PAREN + | ; -execute_stmt - : EXECUTE name=identifier expr_list? +seqoptlist + : seqoptelem+ ; -explain_stmt - : ((EXPLAIN ANALYZE? VERBOSE?) - | (EXPLAIN OPEN_PAREN explain_parameter (COMMA explain_parameter)* CLOSE_PAREN)) - (select_stmt|insert_stmt|update_stmt|delete_stmt|values_stmt|execute_stmt|declare_stmt|create_table_as_stmt|create_materialized_view_stmt) +seqoptelem + : AS simpletypename + | CACHE numericonly + | CYCLE + | INCREMENT opt_by numericonly + | MAXVALUE numericonly + | MINVALUE numericonly + | NO (MAXVALUE | MINVALUE | CYCLE) + | OWNED BY any_name + | SEQUENCE NAME_P any_name + | START opt_with numericonly + | RESTART opt_with numericonly? ; -fetch_stmt - : todo_implement +opt_by + : BY + | ; -grant_stmt - : todo_implement +numericonly + : fconst + | PLUS fconst + | MINUS fconst + | signediconst ; -import_foreign_schema_stmt - : todo_implement +numericonly_list + : numericonly (COMMA numericonly)* ; -insert_stmt - : with_clause? - INSERT INTO table_name_ (AS alias_=identifier)? (OPEN_PAREN name_list CLOSE_PAREN)? - (OVERRIDING (SYSTEM | USER)? VALUE)? - (DEFAULT VALUES | select_stmt | values_stmt) - (ON CONFLICT - (OPEN_PAREN column_name CLOSE_PAREN)? - (ON CONSTRAINT column_name)? - where_clause? - ((DO NOTHING)|(DO UPDATE SET updater_clause where_clause?)) +createplangstmt + : CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name ( + HANDLER handler_name opt_inline_handler opt_validator )? - returning_clause? ; -listen_stmt - : LISTEN channel=identifier +opt_trusted + : TRUSTED + | ; -load_stmt - : todo_implement +handler_name + : name attrs? ; -lock_stmt - : LOCK TABLE? ONLY? name=name_ STAR? (IN - (ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE - | SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE) MODE)? NOWAIT? +opt_inline_handler + : INLINE_P handler_name + | ; -move_stmt - : MOVE ((NEXT | PRIOR | FIRST | LAST | ABSOLUTE INTEGER | RELATIVE parameterOrIntegerLiteral | parameterOrIntegerLiteral | - ALL | FORWARD (parameterOrIntegerLiteral|ALL)? | BACKWARD (parameterOrIntegerLiteral|ALL)?) (FROM|IN)?)? cursor_name=name_ +validator_clause + : VALIDATOR handler_name + | NO VALIDATOR ; -notify_stmt - : NOTIFY channel=name_ (COMMA payload=SINGLEQ_STRING_LITERAL)? +opt_validator + : validator_clause + | ; -prepare_stmt - : PREPARE name=identifier (OPEN_PAREN data_type_list CLOSE_PAREN)? AS - (select_stmt|insert_stmt|update_stmt|delete_stmt|values_stmt) +opt_procedural + : PROCEDURAL + | ; -prepare_transaction_stmt - : PREPARE TRANSACTION name=name_ +createtablespacestmt + : CREATE TABLESPACE name opttablespaceowner LOCATION sconst opt_reloptions ; -reassign_owned_stmt - : REASSIGN OWNED - BY ((identifier|CURRENT_USER|SESSION_USER) (COMMA (identifier|CURRENT_USER|SESSION_USER))*) - TO (identifier|CURRENT_USER|SESSION_USER) +opttablespaceowner + : OWNER rolespec + | ; -refresh_materialized_view_stmt - : todo_implement +droptablespacestmt + : DROP TABLESPACE (IF_P EXISTS)? name ; -reindex_stmt - : REINDEX (OPEN_PAREN VERBOSE CLOSE_PAREN)? (INDEX | TABLE | SCHEMA | DATABASE | SYSTEM) name=identifier +createextensionstmt + : CREATE EXTENSION (IF_P NOT EXISTS)? name opt_with create_extension_opt_list ; -release_savepoint_stmt - : RELEASE SAVEPOINT? savepoint_name=identifier +create_extension_opt_list + : create_extension_opt_item* ; -reset_stmt - : RESET (configuration_parameter=identifier | ALL) +create_extension_opt_item + : SCHEMA name + | VERSION_P nonreservedword_or_sconst + | FROM nonreservedword_or_sconst + | CASCADE ; -revoke_stmt - : todo_implement +alterextensionstmt + : ALTER EXTENSION name UPDATE alter_extension_opt_list ; -rollback_stmt - : ROLLBACK (WORK | TRANSACTION)? +alter_extension_opt_list + : alter_extension_opt_item* ; -rollback_prepared_stmt - : ROLLBACK PREPARED transaction_id=INTEGER_LITERAL +alter_extension_opt_item + : TO nonreservedword_or_sconst ; -rollback_to_savepoint_stmt - : ROLLBACK (WORK | TRANSACTION)? TO SAVEPOINT? savepoint_name=identifier +alterextensioncontentsstmt + : ALTER EXTENSION name add_drop object_type_name name + | ALTER EXTENSION name add_drop object_type_any_name any_name + | ALTER EXTENSION name add_drop AGGREGATE aggregate_with_argtypes + | ALTER EXTENSION name add_drop CAST OPEN_PAREN typename AS typename CLOSE_PAREN + | ALTER EXTENSION name add_drop DOMAIN_P typename + | ALTER EXTENSION name add_drop FUNCTION function_with_argtypes + | ALTER EXTENSION name add_drop OPERATOR operator_with_argtypes + | ALTER EXTENSION name add_drop OPERATOR CLASS any_name USING name + | ALTER EXTENSION name add_drop OPERATOR FAMILY any_name USING name + | ALTER EXTENSION name add_drop PROCEDURE function_with_argtypes + | ALTER EXTENSION name add_drop ROUTINE function_with_argtypes + | ALTER EXTENSION name add_drop TRANSFORM FOR typename LANGUAGE name + | ALTER EXTENSION name add_drop TYPE_P typename ; -savepoint_stmt - : SAVEPOINT savepoint_name=identifier +createfdwstmt + : CREATE FOREIGN DATA_P WRAPPER name opt_fdw_options create_generic_options ; -security_label_stmt - : SECURITY LABEL (FOR provider=name_)? ON - ( TABLE object_name=identifier - | COLUMN table_name=identifier DOT column_name_=column_name - | AGGREGATE aggregate_name=identifier OPEN_PAREN aggregate_signature CLOSE_PAREN - | DATABASE object_name=identifier - | DOMAIN object_name=identifier - | EVENT TRIGGER object_name=identifier - | FOREIGN TABLE object_name=identifier - | FUNCTION function_name=identifier func_sig - | LARGE OBJECT large_object_oid=INTEGER_LITERAL - | MATERIALIZED VIEW object_name=identifier - | PROCEDURAL? LANGUAGE object_name=identifier - | PUBLICATION object_name=identifier - | ROLE object_name=identifier - | SCHEMA object_name=identifier - | SEQUENCE object_name=identifier - | SUBSCRIPTION object_name=identifier - | TABLESPACE object_name=identifier - | TYPE object_name=identifier - | VIEW object_name=identifier - ) IS label=SINGLEQ_STRING_LITERAL +fdw_option + : HANDLER handler_name + | NO HANDLER + | VALIDATOR handler_name + | NO VALIDATOR ; -select_stmt - : with_clause? - ((SELECT - selector_clause - from_clause?) - | (TABLE ONLY? table_name_ STAR?) - | (OPEN_PAREN+ select_stmt CLOSE_PAREN+ combine_clause) - ) - where_clause? - group_by_clause? - having_clause? - window_clause? - combine_clause? - order_by_clause? - limit_clause? - offset_clause? - fetch_clause? - for_clause? +fdw_options + : fdw_option+ ; -select_into_stmt - : with_clause? - ((SELECT - selector_clause - INTO (TEMPORARY | TEMP | UNLOGGED)? TABLE? new_table=table_name_ - from_clause?) - | (TABLE ONLY? table_name_ STAR?) - | (OPEN_PAREN+ select_stmt CLOSE_PAREN+ combine_clause) - ) - where_clause? - group_by_clause? - having_clause? - window_clause? - combine_clause? - order_by_clause? - limit_clause? - offset_clause? - fetch_clause? - for_clause? +opt_fdw_options + : fdw_options + | ; -with_clause: - WITH RECURSIVE? with_expr (COMMA with_expr)* +alterfdwstmt + : ALTER FOREIGN DATA_P WRAPPER name opt_fdw_options alter_generic_options + | ALTER FOREIGN DATA_P WRAPPER name fdw_options ; -with_expr: - table_name_ (OPEN_PAREN name_list CLOSE_PAREN)? - AS OPEN_PAREN (select_stmt|insert_stmt|delete_stmt|update_stmt|values_stmt) CLOSE_PAREN +create_generic_options + : OPTIONS OPEN_PAREN generic_option_list CLOSE_PAREN + | ; -set_stmt - : SET (SESSION | LOCAL)? configuration_parameter=identifier (TO | EQUAL) (value=param_value | DEFAULT) - | SET (SESSION | LOCAL)? TIME ZONE (timezone | LOCAL | DEFAULT) +generic_option_list + : generic_option_elem (COMMA generic_option_elem)* ; -set_constraints_stmt - : SET CONSTRAINTS (ALL | constraints=identifier_list) (DEFERRED | IMMEDIATE) +alter_generic_options + : OPTIONS OPEN_PAREN alter_generic_option_list CLOSE_PAREN ; -set_role_stmt - : SET (SESSION | LOCAL)? ROLE (role_name_=role_name | NONE) - | RESET ROLE +alter_generic_option_list + : alter_generic_option_elem (COMMA alter_generic_option_elem)* ; -set_session_authorization_stmt - : todo_implement +alter_generic_option_elem + : generic_option_elem + | SET generic_option_elem + | ADD_P generic_option_elem + | DROP generic_option_name ; -transaction_mode - : ISOLATION LEVEL (SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED) - | READ WRITE +generic_option_elem + : generic_option_name generic_option_arg + ; + +generic_option_name + : collabel + ; + +generic_option_arg + : sconst + ; + +createforeignserverstmt + : CREATE SERVER name opt_type opt_foreign_server_version FOREIGN DATA_P WRAPPER name create_generic_options + | CREATE SERVER IF_P NOT EXISTS name opt_type opt_foreign_server_version FOREIGN DATA_P WRAPPER name create_generic_options + ; + +opt_type + : TYPE_P sconst + | + ; + +foreign_server_version + : VERSION_P (sconst | NULL_P) + ; + +opt_foreign_server_version + : foreign_server_version + | + ; + +alterforeignserverstmt + : ALTER SERVER name (alter_generic_options | foreign_server_version alter_generic_options?) + ; + +createforeigntablestmt + : CREATE FOREIGN TABLE qualified_name OPEN_PAREN opttableelementlist CLOSE_PAREN optinherit SERVER name create_generic_options + | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name OPEN_PAREN opttableelementlist CLOSE_PAREN optinherit SERVER name create_generic_options + | CREATE FOREIGN TABLE qualified_name PARTITION OF qualified_name opttypedtableelementlist partitionboundspec SERVER name create_generic_options + | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name PARTITION OF qualified_name opttypedtableelementlist partitionboundspec SERVER name + create_generic_options + ; + +importforeignschemastmt + : IMPORT_P FOREIGN SCHEMA name import_qualification FROM SERVER name INTO name create_generic_options + ; + +import_qualification_type + : LIMIT TO + | EXCEPT + ; + +import_qualification + : import_qualification_type OPEN_PAREN relation_expr_list CLOSE_PAREN + | + ; + +createusermappingstmt + : CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options + | CREATE USER MAPPING IF_P NOT EXISTS FOR auth_ident SERVER name create_generic_options + ; + +auth_ident + : rolespec + | USER + ; + +dropusermappingstmt + : DROP USER MAPPING FOR auth_ident SERVER name + | DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name + ; + +alterusermappingstmt + : ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options + ; + +createpolicystmt + : CREATE POLICY name ON qualified_name rowsecuritydefaultpermissive rowsecuritydefaultforcmd rowsecuritydefaulttorole rowsecurityoptionalexpr + rowsecurityoptionalwithcheck + ; + +alterpolicystmt + : ALTER POLICY name ON qualified_name rowsecurityoptionaltorole rowsecurityoptionalexpr rowsecurityoptionalwithcheck + ; + +rowsecurityoptionalexpr + : USING OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +rowsecurityoptionalwithcheck + : WITH CHECK OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +rowsecuritydefaulttorole + : TO role_list + | + ; + +rowsecurityoptionaltorole + : TO role_list + | + ; + +rowsecuritydefaultpermissive + : AS identifier + | + ; + +rowsecuritydefaultforcmd + : FOR row_security_cmd + | + ; + +row_security_cmd + : ALL + | SELECT + | INSERT + | UPDATE + | DELETE_P + ; + +createamstmt + : CREATE ACCESS METHOD name TYPE_P am_type HANDLER handler_name + ; + +am_type + : INDEX + | TABLE + ; + +createtrigstmt + : CREATE TRIGGER name triggeractiontime triggerevents ON qualified_name triggerreferencing triggerforspec triggerwhen EXECUTE + function_or_procedure func_name OPEN_PAREN triggerfuncargs CLOSE_PAREN + | CREATE CONSTRAINT TRIGGER name AFTER triggerevents ON qualified_name optconstrfromtable constraintattributespec FOR EACH ROW triggerwhen EXECUTE + function_or_procedure func_name OPEN_PAREN triggerfuncargs CLOSE_PAREN + ; + +triggeractiontime + : BEFORE + | AFTER + | INSTEAD OF + ; + +triggerevents + : triggeroneevent (OR triggeroneevent)* + ; + +triggeroneevent + : INSERT + | DELETE_P + | UPDATE + | UPDATE OF columnlist + | TRUNCATE + ; + +triggerreferencing + : REFERENCING triggertransitions + | + ; + +triggertransitions + : triggertransition+ + ; + +triggertransition + : transitionoldornew transitionrowortable opt_as transitionrelname + ; + +transitionoldornew + : NEW + | OLD + ; + +transitionrowortable + : TABLE + | ROW + ; + +transitionrelname + : colid + ; + +triggerforspec + : FOR triggerforopteach triggerfortype + | + ; + +triggerforopteach + : EACH + | + ; + +triggerfortype + : ROW + | STATEMENT + ; + +triggerwhen + : WHEN OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +function_or_procedure + : FUNCTION + | PROCEDURE + ; + +triggerfuncargs + : (triggerfuncarg |) (COMMA triggerfuncarg)* + ; + +triggerfuncarg + : iconst + | fconst + | sconst + | collabel + ; + +optconstrfromtable + : FROM qualified_name + | + ; + +constraintattributespec + : constraintattributeElem* + ; + +constraintattributeElem + : NOT DEFERRABLE + | DEFERRABLE + | INITIALLY IMMEDIATE + | INITIALLY DEFERRED + | NOT VALID + | NO INHERIT + ; + +createeventtrigstmt + : CREATE EVENT TRIGGER name ON collabel EXECUTE function_or_procedure func_name OPEN_PAREN CLOSE_PAREN + | CREATE EVENT TRIGGER name ON collabel WHEN event_trigger_when_list EXECUTE function_or_procedure func_name OPEN_PAREN CLOSE_PAREN + ; + +event_trigger_when_list + : event_trigger_when_item (AND event_trigger_when_item)* + ; + +event_trigger_when_item + : colid IN_P OPEN_PAREN event_trigger_value_list CLOSE_PAREN + ; + +event_trigger_value_list + : sconst (COMMA sconst)* + ; + +altereventtrigstmt + : ALTER EVENT TRIGGER name enable_trigger + ; + +enable_trigger + : ENABLE_P + | ENABLE_P REPLICA + | ENABLE_P ALWAYS + | DISABLE_P + ; + +createassertionstmt + : CREATE ASSERTION any_name CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec + ; + +definestmt + : CREATE opt_or_replace AGGREGATE func_name aggr_args definition + | CREATE opt_or_replace AGGREGATE func_name old_aggr_definition + | CREATE OPERATOR any_operator definition + | CREATE TYPE_P any_name definition + | CREATE TYPE_P any_name + | CREATE TYPE_P any_name AS OPEN_PAREN opttablefuncelementlist CLOSE_PAREN + | CREATE TYPE_P any_name AS ENUM_P OPEN_PAREN opt_enum_val_list CLOSE_PAREN + | CREATE TYPE_P any_name AS RANGE definition + | CREATE TEXT_P SEARCH PARSER any_name definition + | CREATE TEXT_P SEARCH DICTIONARY any_name definition + | CREATE TEXT_P SEARCH TEMPLATE any_name definition + | CREATE TEXT_P SEARCH CONFIGURATION any_name definition + | CREATE COLLATION any_name definition + | CREATE COLLATION IF_P NOT EXISTS any_name definition + | CREATE COLLATION any_name FROM any_name + | CREATE COLLATION IF_P NOT EXISTS any_name FROM any_name + ; + +definition + : OPEN_PAREN def_list CLOSE_PAREN + ; + +def_list + : def_elem (COMMA def_elem)* + ; + +def_elem + : collabel (EQUAL def_arg)? + ; + +def_arg + : func_type + | reserved_keyword + | qual_all_op + | numericonly + | sconst + | NONE + ; + +old_aggr_definition + : OPEN_PAREN old_aggr_list CLOSE_PAREN + ; + +old_aggr_list + : old_aggr_elem (COMMA old_aggr_elem)* + ; + +old_aggr_elem + : identifier EQUAL def_arg + ; + +opt_enum_val_list + : enum_val_list + | + ; + +enum_val_list + : sconst (COMMA sconst)* + ; + +alterenumstmt + : ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists sconst + | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists sconst BEFORE sconst + | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists sconst AFTER sconst + | ALTER TYPE_P any_name RENAME VALUE_P sconst TO sconst + ; + +opt_if_not_exists + : IF_P NOT EXISTS + | + ; + +createopclassstmt + : CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P typename USING name opt_opfamily AS opclass_item_list + ; + +opclass_item_list + : opclass_item (COMMA opclass_item)* + ; + +opclass_item + : OPERATOR iconst any_operator opclass_purpose opt_recheck + | OPERATOR iconst operator_with_argtypes opclass_purpose opt_recheck + | FUNCTION iconst function_with_argtypes + | FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN function_with_argtypes + | STORAGE typename + ; + +opt_default + : DEFAULT + | + ; + +opt_opfamily + : FAMILY any_name + | + ; + +opclass_purpose + : FOR SEARCH + | FOR ORDER BY any_name + | + ; + +opt_recheck + : RECHECK + | + ; + +createopfamilystmt + : CREATE OPERATOR FAMILY any_name USING name + ; + +alteropfamilystmt + : ALTER OPERATOR FAMILY any_name USING name ADD_P opclass_item_list + | ALTER OPERATOR FAMILY any_name USING name DROP opclass_drop_list + ; + +opclass_drop_list + : opclass_drop (COMMA opclass_drop)* + ; + +opclass_drop + : OPERATOR iconst OPEN_PAREN type_list CLOSE_PAREN + | FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN + ; + +dropopclassstmt + : DROP OPERATOR CLASS any_name USING name opt_drop_behavior + | DROP OPERATOR CLASS IF_P EXISTS any_name USING name opt_drop_behavior + ; + +dropopfamilystmt + : DROP OPERATOR FAMILY any_name USING name opt_drop_behavior + | DROP OPERATOR FAMILY IF_P EXISTS any_name USING name opt_drop_behavior + ; + +dropownedstmt + : DROP OWNED BY role_list opt_drop_behavior + ; + +reassignownedstmt + : REASSIGN OWNED BY role_list TO rolespec + ; + +dropstmt + : DROP object_type_any_name IF_P EXISTS any_name_list opt_drop_behavior + | DROP object_type_any_name any_name_list opt_drop_behavior + | DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior + | DROP drop_type_name name_list opt_drop_behavior + | DROP object_type_name_on_any_name name ON any_name opt_drop_behavior + | DROP object_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior + | DROP TYPE_P type_name_list opt_drop_behavior + | DROP TYPE_P IF_P EXISTS type_name_list opt_drop_behavior + | DROP DOMAIN_P type_name_list opt_drop_behavior + | DROP DOMAIN_P IF_P EXISTS type_name_list opt_drop_behavior + | DROP INDEX CONCURRENTLY any_name_list opt_drop_behavior + | DROP INDEX CONCURRENTLY IF_P EXISTS any_name_list opt_drop_behavior + ; + +object_type_any_name + : TABLE + | SEQUENCE + | VIEW + | MATERIALIZED VIEW + | INDEX + | FOREIGN TABLE + | COLLATION + | CONVERSION_P + | STATISTICS + | TEXT_P SEARCH PARSER + | TEXT_P SEARCH DICTIONARY + | TEXT_P SEARCH TEMPLATE + | TEXT_P SEARCH CONFIGURATION + ; + +object_type_name + : drop_type_name + | DATABASE + | ROLE + | SUBSCRIPTION + | TABLESPACE + ; + +drop_type_name + : ACCESS METHOD + | EVENT TRIGGER + | EXTENSION + | FOREIGN DATA_P WRAPPER + | opt_procedural LANGUAGE + | PUBLICATION + | SCHEMA + | SERVER + ; + +object_type_name_on_any_name + : POLICY + | RULE + | TRIGGER + ; + +any_name_list + : any_name (COMMA any_name)* + ; + +any_name + : colid attrs? + ; + +attrs + : (DOT attr_name)+ + ; + +type_name_list + : typename (COMMA typename)* + ; + +truncatestmt + : TRUNCATE opt_table relation_expr_list opt_restart_seqs opt_drop_behavior + ; + +opt_restart_seqs + : CONTINUE_P IDENTITY_P + | RESTART IDENTITY_P + | + ; + +commentstmt + : COMMENT ON object_type_any_name any_name IS comment_text + | COMMENT ON COLUMN any_name IS comment_text + | COMMENT ON object_type_name name IS comment_text + | COMMENT ON TYPE_P typename IS comment_text + | COMMENT ON DOMAIN_P typename IS comment_text + | COMMENT ON AGGREGATE aggregate_with_argtypes IS comment_text + | COMMENT ON FUNCTION function_with_argtypes IS comment_text + | COMMENT ON OPERATOR operator_with_argtypes IS comment_text + | COMMENT ON CONSTRAINT name ON any_name IS comment_text + | COMMENT ON CONSTRAINT name ON DOMAIN_P any_name IS comment_text + | COMMENT ON object_type_name_on_any_name name ON any_name IS comment_text + | COMMENT ON PROCEDURE function_with_argtypes IS comment_text + | COMMENT ON ROUTINE function_with_argtypes IS comment_text + | COMMENT ON TRANSFORM FOR typename LANGUAGE name IS comment_text + | COMMENT ON OPERATOR CLASS any_name USING name IS comment_text + | COMMENT ON OPERATOR FAMILY any_name USING name IS comment_text + | COMMENT ON LARGE_P OBJECT_P numericonly IS comment_text + | COMMENT ON CAST OPEN_PAREN typename AS typename CLOSE_PAREN IS comment_text + ; + +comment_text + : sconst + | NULL_P + ; + +seclabelstmt + : SECURITY LABEL opt_provider ON object_type_any_name any_name IS security_label + | SECURITY LABEL opt_provider ON COLUMN any_name IS security_label + | SECURITY LABEL opt_provider ON object_type_name name IS security_label + | SECURITY LABEL opt_provider ON TYPE_P typename IS security_label + | SECURITY LABEL opt_provider ON DOMAIN_P typename IS security_label + | SECURITY LABEL opt_provider ON AGGREGATE aggregate_with_argtypes IS security_label + | SECURITY LABEL opt_provider ON FUNCTION function_with_argtypes IS security_label + | SECURITY LABEL opt_provider ON LARGE_P OBJECT_P numericonly IS security_label + | SECURITY LABEL opt_provider ON PROCEDURE function_with_argtypes IS security_label + | SECURITY LABEL opt_provider ON ROUTINE function_with_argtypes IS security_label + ; + +opt_provider + : FOR nonreservedword_or_sconst + | + ; + +security_label + : sconst + | NULL_P + ; + +fetchstmt + : FETCH fetch_args + | MOVE fetch_args + ; + +fetch_args + : cursor_name + | from_in cursor_name + | NEXT opt_from_in cursor_name + | PRIOR opt_from_in cursor_name + | FIRST_P opt_from_in cursor_name + | LAST_P opt_from_in cursor_name + | ABSOLUTE_P signediconst opt_from_in cursor_name + | RELATIVE_P signediconst opt_from_in cursor_name + | signediconst opt_from_in cursor_name + | ALL opt_from_in cursor_name + | FORWARD opt_from_in cursor_name + | FORWARD signediconst opt_from_in cursor_name + | FORWARD ALL opt_from_in cursor_name + | BACKWARD opt_from_in cursor_name + | BACKWARD signediconst opt_from_in cursor_name + | BACKWARD ALL opt_from_in cursor_name + ; + +from_in + : FROM + | IN_P + ; + +opt_from_in + : from_in + | + ; + +grantstmt + : GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option + ; + +revokestmt + : REVOKE privileges ON privilege_target FROM grantee_list opt_drop_behavior + | REVOKE GRANT OPTION FOR privileges ON privilege_target FROM grantee_list opt_drop_behavior + ; + +privileges + : privilege_list + | ALL + | ALL PRIVILEGES + | ALL OPEN_PAREN columnlist CLOSE_PAREN + | ALL PRIVILEGES OPEN_PAREN columnlist CLOSE_PAREN + ; + +privilege_list + : privilege (COMMA privilege)* + ; + +privilege + : SELECT opt_column_list + | REFERENCES opt_column_list + | CREATE opt_column_list + | colid opt_column_list + ; + +privilege_target + : qualified_name_list + | TABLE qualified_name_list + | SEQUENCE qualified_name_list + | FOREIGN DATA_P WRAPPER name_list + | FOREIGN SERVER name_list + | FUNCTION function_with_argtypes_list + | PROCEDURE function_with_argtypes_list + | ROUTINE function_with_argtypes_list + | DATABASE name_list + | DOMAIN_P any_name_list + | LANGUAGE name_list + | LARGE_P OBJECT_P numericonly_list + | SCHEMA name_list + | TABLESPACE name_list + | TYPE_P any_name_list + | ALL TABLES IN_P SCHEMA name_list + | ALL SEQUENCES IN_P SCHEMA name_list + | ALL FUNCTIONS IN_P SCHEMA name_list + | ALL PROCEDURES IN_P SCHEMA name_list + | ALL ROUTINES IN_P SCHEMA name_list + ; + +grantee_list + : grantee (COMMA grantee)* + ; + +grantee + : rolespec + | GROUP_P rolespec + ; + +opt_grant_grant_option + : WITH GRANT OPTION + | + ; + +grantrolestmt + : GRANT privilege_list TO role_list opt_grant_admin_option opt_granted_by + ; + +revokerolestmt + : REVOKE privilege_list FROM role_list opt_granted_by opt_drop_behavior + | REVOKE ADMIN OPTION FOR privilege_list FROM role_list opt_granted_by opt_drop_behavior + ; + +opt_grant_admin_option + : WITH ADMIN OPTION + | + ; + +opt_granted_by + : GRANTED BY rolespec + | + ; + +alterdefaultprivilegesstmt + : ALTER DEFAULT PRIVILEGES defacloptionlist defaclaction + ; + +defacloptionlist + : defacloption* + ; + +defacloption + : IN_P SCHEMA name_list + | FOR ROLE role_list + | FOR USER role_list + ; + +defaclaction + : GRANT privileges ON defacl_privilege_target TO grantee_list opt_grant_grant_option + | REVOKE privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior + | REVOKE GRANT OPTION FOR privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior + ; + +defacl_privilege_target + : TABLES + | FUNCTIONS + | ROUTINES + | SEQUENCES + | TYPES_P + | SCHEMAS + ; + +//create index + +indexstmt + : CREATE opt_unique INDEX opt_concurrently opt_index_name ON relation_expr access_method_clause OPEN_PAREN index_params CLOSE_PAREN opt_include + opt_reloptions opttablespace where_clause + | CREATE opt_unique INDEX opt_concurrently IF_P NOT EXISTS name ON relation_expr access_method_clause OPEN_PAREN index_params CLOSE_PAREN + opt_include opt_reloptions opttablespace where_clause + ; + +opt_unique + : UNIQUE + | + ; + +opt_concurrently + : CONCURRENTLY + | + ; + +opt_index_name + : name + | + ; + +access_method_clause + : USING name + | + ; + +index_params + : index_elem (COMMA index_elem)* + ; + +index_elem_options + : opt_collate opt_class opt_asc_desc opt_nulls_order + | opt_collate any_name reloptions opt_asc_desc opt_nulls_order + ; + +index_elem + : colid index_elem_options + | func_expr_windowless index_elem_options + | OPEN_PAREN a_expr CLOSE_PAREN index_elem_options + ; + +opt_include + : INCLUDE OPEN_PAREN index_including_params CLOSE_PAREN + | + ; + +index_including_params + : index_elem (COMMA index_elem)* + ; + +opt_collate + : COLLATE any_name + | + ; + +opt_class + : any_name + | + ; + +opt_asc_desc + : ASC + | DESC + | + ; + +//TOD NULLS_LA was used + +opt_nulls_order + : NULLS_P FIRST_P + | NULLS_P LAST_P + | + ; + +createfunctionstmt + : CREATE opt_or_replace (FUNCTION | PROCEDURE) func_name func_args_with_defaults ( + RETURNS (func_return | TABLE OPEN_PAREN table_func_column_list CLOSE_PAREN) + )? createfunc_opt_list + ; + +opt_or_replace + : OR REPLACE + | + ; + +func_args + : OPEN_PAREN func_args_list? CLOSE_PAREN + ; + +func_args_list + : func_arg (COMMA func_arg)* + ; + +function_with_argtypes_list + : function_with_argtypes (COMMA function_with_argtypes)* + ; + +function_with_argtypes + : func_name func_args + | type_func_name_keyword + | colid indirection? + ; + +func_args_with_defaults + : OPEN_PAREN func_args_with_defaults_list? CLOSE_PAREN + ; + +func_args_with_defaults_list + : func_arg_with_default (COMMA func_arg_with_default)* + ; + +func_arg + : arg_class param_name? func_type + | param_name arg_class? func_type + | func_type + ; + +arg_class + : IN_P OUT_P? + | OUT_P + | INOUT + | VARIADIC + ; + +param_name + : type_function_name + | builtin_function_name + | LEFT + | RIGHT + ; + +func_return + : func_type + ; + +func_type + : typename + | SETOF? (builtin_function_name | type_function_name | LEFT | RIGHT) attrs PERCENT TYPE_P + ; + +func_arg_with_default + : func_arg ((DEFAULT | EQUAL) a_expr)? + ; + +aggr_arg + : func_arg + ; + +aggr_args + : OPEN_PAREN ( + STAR + | aggr_args_list + | ORDER BY aggr_args_list + | aggr_args_list ORDER BY aggr_args_list + ) CLOSE_PAREN + ; + +aggr_args_list + : aggr_arg (COMMA aggr_arg)* + ; + +aggregate_with_argtypes + : func_name aggr_args + ; + +aggregate_with_argtypes_list + : aggregate_with_argtypes (COMMA aggregate_with_argtypes)* + ; + +createfunc_opt_list + : createfunc_opt_item+ { + ParseRoutineBody(_localctx); + } + // | createfunc_opt_list createfunc_opt_item + ; + +common_func_opt_item + : CALLED ON NULL_P INPUT_P + | RETURNS NULL_P ON NULL_P INPUT_P + | STRICT_P + | IMMUTABLE + | STABLE + | VOLATILE + | EXTERNAL SECURITY DEFINER + | EXTERNAL SECURITY INVOKER + | SECURITY DEFINER + | SECURITY INVOKER + | LEAKPROOF + | NOT LEAKPROOF + | COST numericonly + | ROWS numericonly + | SUPPORT any_name + | functionsetresetclause + | PARALLEL colid + ; + +createfunc_opt_item + : AS func_as + | LANGUAGE nonreservedword_or_sconst + | TRANSFORM transform_type_list + | WINDOW + | common_func_opt_item + ; + +//https://www.postgresql.org/docs/9.1/sql-createfunction.html + +// | AS 'definition' + +// | AS 'obj_file', 'link_symbol' + +func_as + locals[ParserRuleContext Definition] + : + /* |AS 'definition'*/ def = sconst + /*| AS 'obj_file', 'link_symbol'*/ + | sconst COMMA sconst + ; + +transform_type_list + : FOR TYPE_P typename (COMMA FOR TYPE_P typename)* + ; + +opt_definition + : WITH definition + | + ; + +table_func_column + : param_name func_type + ; + +table_func_column_list + : table_func_column (COMMA table_func_column)* + ; + +alterfunctionstmt + : ALTER (FUNCTION | PROCEDURE | ROUTINE) function_with_argtypes alterfunc_opt_list opt_restrict + ; + +alterfunc_opt_list + : common_func_opt_item+ + ; + +opt_restrict + : RESTRICT + | + ; + +removefuncstmt + : DROP FUNCTION function_with_argtypes_list opt_drop_behavior + | DROP FUNCTION IF_P EXISTS function_with_argtypes_list opt_drop_behavior + | DROP PROCEDURE function_with_argtypes_list opt_drop_behavior + | DROP PROCEDURE IF_P EXISTS function_with_argtypes_list opt_drop_behavior + | DROP ROUTINE function_with_argtypes_list opt_drop_behavior + | DROP ROUTINE IF_P EXISTS function_with_argtypes_list opt_drop_behavior + ; + +removeaggrstmt + : DROP AGGREGATE aggregate_with_argtypes_list opt_drop_behavior + | DROP AGGREGATE IF_P EXISTS aggregate_with_argtypes_list opt_drop_behavior + ; + +removeoperstmt + : DROP OPERATOR operator_with_argtypes_list opt_drop_behavior + | DROP OPERATOR IF_P EXISTS operator_with_argtypes_list opt_drop_behavior + ; + +oper_argtypes + : OPEN_PAREN typename CLOSE_PAREN + | OPEN_PAREN typename COMMA typename CLOSE_PAREN + | OPEN_PAREN NONE COMMA typename CLOSE_PAREN + | OPEN_PAREN typename COMMA NONE CLOSE_PAREN + ; + +any_operator + : (colid DOT)* all_op + ; + +operator_with_argtypes_list + : operator_with_argtypes (COMMA operator_with_argtypes)* + ; + +operator_with_argtypes + : any_operator oper_argtypes + ; + +dostmt + : DO dostmt_opt_list + ; + +dostmt_opt_list + : dostmt_opt_item+ + ; + +dostmt_opt_item + : sconst + | LANGUAGE nonreservedword_or_sconst + ; + +createcaststmt + : CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITH FUNCTION function_with_argtypes cast_context + | CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITHOUT FUNCTION cast_context + | CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITH INOUT cast_context + ; + +cast_context + : AS IMPLICIT_P + | AS ASSIGNMENT + | + ; + +dropcaststmt + : DROP CAST opt_if_exists OPEN_PAREN typename AS typename CLOSE_PAREN opt_drop_behavior + ; + +opt_if_exists + : IF_P EXISTS + | + ; + +createtransformstmt + : CREATE opt_or_replace TRANSFORM FOR typename LANGUAGE name OPEN_PAREN transform_element_list CLOSE_PAREN + ; + +transform_element_list + : FROM SQL_P WITH FUNCTION function_with_argtypes COMMA TO SQL_P WITH FUNCTION function_with_argtypes + | TO SQL_P WITH FUNCTION function_with_argtypes COMMA FROM SQL_P WITH FUNCTION function_with_argtypes + | FROM SQL_P WITH FUNCTION function_with_argtypes + | TO SQL_P WITH FUNCTION function_with_argtypes + ; + +droptransformstmt + : DROP TRANSFORM opt_if_exists FOR typename LANGUAGE name opt_drop_behavior + ; + +reindexstmt + : REINDEX reindex_target_type opt_concurrently qualified_name + | REINDEX reindex_target_multitable opt_concurrently name + | REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_type opt_concurrently qualified_name + | REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_multitable opt_concurrently name + ; + +reindex_target_type + : INDEX + | TABLE + | SCHEMA + | DATABASE + | SYSTEM_P + ; + +reindex_target_multitable + : SCHEMA + | SYSTEM_P + | DATABASE + ; + +reindex_option_list + : reindex_option_elem (COMMA reindex_option_elem)* + ; + +reindex_option_elem + : VERBOSE + | TABLESPACE + | CONCURRENTLY + ; + +altertblspcstmt + : ALTER TABLESPACE name SET reloptions + | ALTER TABLESPACE name RESET reloptions + ; + +renamestmt + : ALTER AGGREGATE aggregate_with_argtypes RENAME TO name + | ALTER COLLATION any_name RENAME TO name + | ALTER CONVERSION_P any_name RENAME TO name + | ALTER DATABASE name RENAME TO name + | ALTER DOMAIN_P any_name RENAME TO name + | ALTER DOMAIN_P any_name RENAME CONSTRAINT name TO name + | ALTER FOREIGN DATA_P WRAPPER name RENAME TO name + | ALTER FUNCTION function_with_argtypes RENAME TO name + | ALTER GROUP_P roleid RENAME TO roleid + | ALTER opt_procedural LANGUAGE name RENAME TO name + | ALTER OPERATOR CLASS any_name USING name RENAME TO name + | ALTER OPERATOR FAMILY any_name USING name RENAME TO name + | ALTER POLICY name ON qualified_name RENAME TO name + | ALTER POLICY IF_P EXISTS name ON qualified_name RENAME TO name + | ALTER PROCEDURE function_with_argtypes RENAME TO name + | ALTER PUBLICATION name RENAME TO name + | ALTER ROUTINE function_with_argtypes RENAME TO name + | ALTER SCHEMA name RENAME TO name + | ALTER SERVER name RENAME TO name + | ALTER SUBSCRIPTION name RENAME TO name + | ALTER TABLE relation_expr RENAME TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME TO name + | ALTER SEQUENCE qualified_name RENAME TO name + | ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name + | ALTER VIEW qualified_name RENAME TO name + | ALTER VIEW IF_P EXISTS qualified_name RENAME TO name + | ALTER MATERIALIZED VIEW qualified_name RENAME TO name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME TO name + | ALTER INDEX qualified_name RENAME TO name + | ALTER INDEX IF_P EXISTS qualified_name RENAME TO name + | ALTER FOREIGN TABLE relation_expr RENAME TO name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME TO name + | ALTER TABLE relation_expr RENAME opt_column name TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name + | ALTER VIEW qualified_name RENAME opt_column name TO name + | ALTER VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name + | ALTER MATERIALIZED VIEW qualified_name RENAME opt_column name TO name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name + | ALTER TABLE relation_expr RENAME CONSTRAINT name TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name + | ALTER FOREIGN TABLE relation_expr RENAME opt_column name TO name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name + | ALTER RULE name ON qualified_name RENAME TO name + | ALTER TRIGGER name ON qualified_name RENAME TO name + | ALTER EVENT TRIGGER name RENAME TO name + | ALTER ROLE roleid RENAME TO roleid + | ALTER USER roleid RENAME TO roleid + | ALTER TABLESPACE name RENAME TO name + | ALTER STATISTICS any_name RENAME TO name + | ALTER TEXT_P SEARCH PARSER any_name RENAME TO name + | ALTER TEXT_P SEARCH DICTIONARY any_name RENAME TO name + | ALTER TEXT_P SEARCH TEMPLATE any_name RENAME TO name + | ALTER TEXT_P SEARCH CONFIGURATION any_name RENAME TO name + | ALTER TYPE_P any_name RENAME TO name + | ALTER TYPE_P any_name RENAME ATTRIBUTE name TO name opt_drop_behavior + ; + +opt_column + : COLUMN + | + ; + +opt_set_data + : SET DATA_P + | + ; + +alterobjectdependsstmt + : ALTER FUNCTION function_with_argtypes opt_no DEPENDS ON EXTENSION name + | ALTER PROCEDURE function_with_argtypes opt_no DEPENDS ON EXTENSION name + | ALTER ROUTINE function_with_argtypes opt_no DEPENDS ON EXTENSION name + | ALTER TRIGGER name ON qualified_name opt_no DEPENDS ON EXTENSION name + | ALTER MATERIALIZED VIEW qualified_name opt_no DEPENDS ON EXTENSION name + | ALTER INDEX qualified_name opt_no DEPENDS ON EXTENSION name + ; + +opt_no + : NO + | + ; + +alterobjectschemastmt + : ALTER AGGREGATE aggregate_with_argtypes SET SCHEMA name + | ALTER COLLATION any_name SET SCHEMA name + | ALTER CONVERSION_P any_name SET SCHEMA name + | ALTER DOMAIN_P any_name SET SCHEMA name + | ALTER EXTENSION name SET SCHEMA name + | ALTER FUNCTION function_with_argtypes SET SCHEMA name + | ALTER OPERATOR operator_with_argtypes SET SCHEMA name + | ALTER OPERATOR CLASS any_name USING name SET SCHEMA name + | ALTER OPERATOR FAMILY any_name USING name SET SCHEMA name + | ALTER PROCEDURE function_with_argtypes SET SCHEMA name + | ALTER ROUTINE function_with_argtypes SET SCHEMA name + | ALTER TABLE relation_expr SET SCHEMA name + | ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name + | ALTER STATISTICS any_name SET SCHEMA name + | ALTER TEXT_P SEARCH PARSER any_name SET SCHEMA name + | ALTER TEXT_P SEARCH DICTIONARY any_name SET SCHEMA name + | ALTER TEXT_P SEARCH TEMPLATE any_name SET SCHEMA name + | ALTER TEXT_P SEARCH CONFIGURATION any_name SET SCHEMA name + | ALTER SEQUENCE qualified_name SET SCHEMA name + | ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name + | ALTER VIEW qualified_name SET SCHEMA name + | ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name + | ALTER MATERIALIZED VIEW qualified_name SET SCHEMA name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name SET SCHEMA name + | ALTER FOREIGN TABLE relation_expr SET SCHEMA name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr SET SCHEMA name + | ALTER TYPE_P any_name SET SCHEMA name + ; + +alteroperatorstmt + : ALTER OPERATOR operator_with_argtypes SET OPEN_PAREN operator_def_list CLOSE_PAREN + ; + +operator_def_list + : operator_def_elem (COMMA operator_def_elem)* + ; + +operator_def_elem + : collabel EQUAL NONE + | collabel EQUAL operator_def_arg + ; + +operator_def_arg + : func_type + | reserved_keyword + | qual_all_op + | numericonly + | sconst + ; + +altertypestmt + : ALTER TYPE_P any_name SET OPEN_PAREN operator_def_list CLOSE_PAREN + ; + +alterownerstmt + : ALTER AGGREGATE aggregate_with_argtypes OWNER TO rolespec + | ALTER COLLATION any_name OWNER TO rolespec + | ALTER CONVERSION_P any_name OWNER TO rolespec + | ALTER DATABASE name OWNER TO rolespec + | ALTER DOMAIN_P any_name OWNER TO rolespec + | ALTER FUNCTION function_with_argtypes OWNER TO rolespec + | ALTER opt_procedural LANGUAGE name OWNER TO rolespec + | ALTER LARGE_P OBJECT_P numericonly OWNER TO rolespec + | ALTER OPERATOR operator_with_argtypes OWNER TO rolespec + | ALTER OPERATOR CLASS any_name USING name OWNER TO rolespec + | ALTER OPERATOR FAMILY any_name USING name OWNER TO rolespec + | ALTER PROCEDURE function_with_argtypes OWNER TO rolespec + | ALTER ROUTINE function_with_argtypes OWNER TO rolespec + | ALTER SCHEMA name OWNER TO rolespec + | ALTER TYPE_P any_name OWNER TO rolespec + | ALTER TABLESPACE name OWNER TO rolespec + | ALTER STATISTICS any_name OWNER TO rolespec + | ALTER TEXT_P SEARCH DICTIONARY any_name OWNER TO rolespec + | ALTER TEXT_P SEARCH CONFIGURATION any_name OWNER TO rolespec + | ALTER FOREIGN DATA_P WRAPPER name OWNER TO rolespec + | ALTER SERVER name OWNER TO rolespec + | ALTER EVENT TRIGGER name OWNER TO rolespec + | ALTER PUBLICATION name OWNER TO rolespec + | ALTER SUBSCRIPTION name OWNER TO rolespec + ; + +createpublicationstmt + : CREATE PUBLICATION name opt_publication_for_tables opt_definition + ; + +opt_publication_for_tables + : publication_for_tables + | + ; + +publication_for_tables + : FOR TABLE relation_expr_list + | FOR ALL TABLES + ; + +alterpublicationstmt + : ALTER PUBLICATION name SET definition + | ALTER PUBLICATION name ADD_P TABLE relation_expr_list + | ALTER PUBLICATION name SET TABLE relation_expr_list + | ALTER PUBLICATION name DROP TABLE relation_expr_list + ; + +createsubscriptionstmt + : CREATE SUBSCRIPTION name CONNECTION sconst PUBLICATION publication_name_list opt_definition + ; + +publication_name_list + : publication_name_item (COMMA publication_name_item)* + ; + +publication_name_item + : collabel + ; + +altersubscriptionstmt + : ALTER SUBSCRIPTION name SET definition + | ALTER SUBSCRIPTION name CONNECTION sconst + | ALTER SUBSCRIPTION name REFRESH PUBLICATION opt_definition + | ALTER SUBSCRIPTION name SET PUBLICATION publication_name_list opt_definition + | ALTER SUBSCRIPTION name ENABLE_P + | ALTER SUBSCRIPTION name DISABLE_P + ; + +dropsubscriptionstmt + : DROP SUBSCRIPTION name opt_drop_behavior + | DROP SUBSCRIPTION IF_P EXISTS name opt_drop_behavior + ; + +rulestmt + : CREATE opt_or_replace RULE name AS ON event TO qualified_name where_clause DO opt_instead ruleactionlist + ; + +ruleactionlist + : NOTHING + | ruleactionstmt + | OPEN_PAREN ruleactionmulti CLOSE_PAREN + ; + +ruleactionmulti + : ruleactionstmtOrEmpty (SEMI ruleactionstmtOrEmpty)* + ; + +ruleactionstmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + | notifystmt + ; + +ruleactionstmtOrEmpty + : ruleactionstmt + | + ; + +event + : SELECT + | UPDATE + | DELETE_P + | INSERT + ; + +opt_instead + : INSTEAD + | ALSO + | + ; + +notifystmt + : NOTIFY colid notify_payload + ; + +notify_payload + : COMMA sconst + | + ; + +listenstmt + : LISTEN colid + ; + +unlistenstmt + : UNLISTEN colid + | UNLISTEN STAR + ; + +transactionstmt + : ABORT_P opt_transaction opt_transaction_chain + | BEGIN_P opt_transaction transaction_mode_list_or_empty + | START TRANSACTION transaction_mode_list_or_empty + | COMMIT opt_transaction opt_transaction_chain + | END_P opt_transaction opt_transaction_chain + | ROLLBACK opt_transaction opt_transaction_chain + | SAVEPOINT colid + | RELEASE SAVEPOINT colid + | RELEASE colid + | ROLLBACK opt_transaction TO SAVEPOINT colid + | ROLLBACK opt_transaction TO colid + | PREPARE TRANSACTION sconst + | COMMIT PREPARED sconst + | ROLLBACK PREPARED sconst + ; + +opt_transaction + : WORK + | TRANSACTION + | + ; + +transaction_mode_item + : ISOLATION LEVEL iso_level | READ ONLY - | NOT? DEFERRABLE + | READ WRITE + | DEFERRABLE + | NOT DEFERRABLE ; transaction_mode_list - : transaction_mode (COMMA transaction_mode)* + : transaction_mode_item (COMMA? transaction_mode_item)* ; -set_transaction_stmt - : SET TRANSACTION transaction_mode_list - | SET TRANSACTION SNAPSHOT snapshot_id=SINGLEQ_STRING_LITERAL - | SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list +transaction_mode_list_or_empty + : transaction_mode_list + | ; -show_stmt - : SHOW (name=identifier | TIME ZONE | ALL) +opt_transaction_chain + : AND NO? CHAIN + | ; -truncate_stmt - : TRUNCATE TABLE? ONLY? table_name_ STAR? (COMMA ONLY? identifier_list)? - ((RESTART | CONTINUE) IDENTITY)? (CASCADE | RESTRICT)? +viewstmt + : CREATE (OR REPLACE)? opttemp ( + VIEW qualified_name opt_column_list opt_reloptions + | RECURSIVE VIEW qualified_name OPEN_PAREN columnlist CLOSE_PAREN opt_reloptions + ) AS selectstmt opt_check_option ; -unlisten_stmt - : UNLISTEN (channel=identifier | STAR) +opt_check_option + : WITH (CASCADED | LOCAL)? CHECK OPTION + | ; -update_stmt - : with_clause? - UPDATE ONLY? table_name_ STAR? (AS? alias_=identifier)? - SET updater_clause - from_clause? - (where_clause | (WHERE CURRENT OF cursor_name_=identifier))? - returning_clause? +loadstmt + : LOAD file_name ; -vacuum_opt - : FULL | FREEZE | VERBOSE | ANALYZE | DISABLE_PAGE_SKIPPING +createdbstmt + : CREATE DATABASE name opt_with createdb_opt_list ; -vacuum_opt_list - : vacuum_opt (COMMA vacuum_opt)* +createdb_opt_list + : createdb_opt_items + | ; -vacuum_stmt - : VACUUM (OPEN_PAREN vacuum_opt_list CLOSE_PAREN)? (table_name=table_name_ (OPEN_PAREN column_list CLOSE_PAREN)?) - | VACUUM FULL? FREEZE? VERBOSE? (table_name=table_name_)? - | VACUUM FULL? FREEZE? VERBOSE? ANALYZE (table_name=table_name_ (OPEN_PAREN column_list CLOSE_PAREN)?)? +createdb_opt_items + : createdb_opt_item+ ; -values_stmt - : with_clause? - ((VALUES expr_list_list) - | (OPEN_PAREN+ values_stmt CLOSE_PAREN+ combine_clause) - ) - order_by_clause? - combine_clause? - limit_clause? - offset_clause? - fetch_clause? +createdb_opt_item + : createdb_opt_name opt_equal (signediconst | opt_boolean_or_string | DEFAULT) ; -selector_clause - :(ALL | (DISTINCT (ON expr_list)?) | TOP INTEGER_LITERAL)? column_list +createdb_opt_name + : identifier + | CONNECTION LIMIT + | ENCODING + | LOCATION + | OWNER + | TABLESPACE + | TEMPLATE ; -from_clause - : FROM from_item (COMMA from_item)* +opt_equal + : EQUAL + | ; -where_clause - : WHERE predicate +alterdatabasestmt + : ALTER DATABASE name (WITH createdb_opt_list | createdb_opt_list | SET TABLESPACE name) ; -group_by_clause - : GROUP BY grouping_elem (COMMA grouping_elem)* +alterdatabasesetstmt + : ALTER DATABASE name setresetclause ; -grouping_elem +dropdbstmt + : DROP DATABASE (IF_P EXISTS)? name (opt_with OPEN_PAREN drop_option_list CLOSE_PAREN)? + ; + +drop_option_list + : drop_option (COMMA drop_option)* + ; + +drop_option + : FORCE + ; + +altercollationstmt + : ALTER COLLATION any_name REFRESH VERSION_P + ; + +altersystemstmt + : ALTER SYSTEM_P (SET | RESET) generic_set + ; + +createdomainstmt + : CREATE DOMAIN_P any_name opt_as typename colquallist + ; + +alterdomainstmt + : ALTER DOMAIN_P any_name ( + alter_column_default + | DROP NOT NULL_P + | SET NOT NULL_P + | ADD_P tableconstraint + | DROP CONSTRAINT (IF_P EXISTS)? name opt_drop_behavior + | VALIDATE CONSTRAINT name + ) + ; + +opt_as + : AS + | + ; + +altertsdictionarystmt + : ALTER TEXT_P SEARCH DICTIONARY any_name definition + ; + +altertsconfigurationstmt + : ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list any_with any_name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list any_with any_name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name any_with any_name + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name any_with any_name + | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list + ; + +any_with + : WITH + //TODO + + // | WITH_LA + ; + +createconversionstmt + : CREATE opt_default CONVERSION_P any_name FOR sconst TO sconst FROM any_name + ; + +clusterstmt + : CLUSTER opt_verbose qualified_name cluster_index_specification + | CLUSTER opt_verbose + | CLUSTER opt_verbose name ON qualified_name + ; + +cluster_index_specification + : USING name + | + ; + +vacuumstmt + : VACUUM opt_full opt_freeze opt_verbose opt_analyze opt_vacuum_relation_list + | VACUUM OPEN_PAREN vac_analyze_option_list CLOSE_PAREN opt_vacuum_relation_list + ; + +analyzestmt + : analyze_keyword opt_verbose opt_vacuum_relation_list + | analyze_keyword OPEN_PAREN vac_analyze_option_list CLOSE_PAREN opt_vacuum_relation_list + ; + +vac_analyze_option_list + : vac_analyze_option_elem (COMMA vac_analyze_option_elem)* + ; + +analyze_keyword + : ANALYZE + | ANALYSE + ; + +vac_analyze_option_elem + : vac_analyze_option_name vac_analyze_option_arg + ; + +vac_analyze_option_name + : nonreservedword + | analyze_keyword + ; + +vac_analyze_option_arg + : opt_boolean_or_string + | numericonly + | + ; + +opt_analyze + : analyze_keyword + | + ; + +opt_verbose + : VERBOSE + | + ; + +opt_full + : FULL + | + ; + +opt_freeze + : FREEZE + | + ; + +opt_name_list + : OPEN_PAREN name_list CLOSE_PAREN + | + ; + +vacuum_relation + : qualified_name opt_name_list + ; + +vacuum_relation_list + : vacuum_relation (COMMA vacuum_relation)* + ; + +opt_vacuum_relation_list + : vacuum_relation_list + | + ; + +explainstmt + : EXPLAIN explainablestmt + | EXPLAIN analyze_keyword opt_verbose explainablestmt + | EXPLAIN VERBOSE explainablestmt + | EXPLAIN OPEN_PAREN explain_option_list CLOSE_PAREN explainablestmt + ; + +explainablestmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + | declarecursorstmt + | createasstmt + | creatematviewstmt + | refreshmatviewstmt + | executestmt + ; + +explain_option_list + : explain_option_elem (COMMA explain_option_elem)* + ; + +explain_option_elem + : explain_option_name explain_option_arg + ; + +explain_option_name + : nonreservedword + | analyze_keyword + ; + +explain_option_arg + : opt_boolean_or_string + | numericonly + | + ; + +preparestmt + : PREPARE name prep_type_clause AS preparablestmt + ; + +prep_type_clause + : OPEN_PAREN type_list CLOSE_PAREN + | + ; + +preparablestmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + ; + +executestmt + : EXECUTE name execute_param_clause + | CREATE opttemp TABLE create_as_target AS EXECUTE name execute_param_clause opt_with_data + | CREATE opttemp TABLE IF_P NOT EXISTS create_as_target AS EXECUTE name execute_param_clause opt_with_data + ; + +execute_param_clause + : OPEN_PAREN expr_list CLOSE_PAREN + | + ; + +deallocatestmt + : DEALLOCATE name + | DEALLOCATE PREPARE name + | DEALLOCATE ALL + | DEALLOCATE PREPARE ALL + ; + +insertstmt + : opt_with_clause INSERT INTO insert_target insert_rest opt_on_conflict returning_clause + ; + +insert_target + : qualified_name (AS colid)? + ; + +insert_rest + : selectstmt + | OVERRIDING override_kind VALUE_P selectstmt + | OPEN_PAREN insert_column_list CLOSE_PAREN (OVERRIDING override_kind VALUE_P)? selectstmt + | DEFAULT VALUES + ; + +override_kind + : USER + | SYSTEM_P + ; + +insert_column_list + : insert_column_item (COMMA insert_column_item)* + ; + +insert_column_item + : colid opt_indirection + ; + +opt_on_conflict + : ON CONFLICT opt_conf_expr DO (UPDATE SET set_clause_list where_clause | NOTHING) + | + ; + +opt_conf_expr + : OPEN_PAREN index_params CLOSE_PAREN where_clause + | ON CONSTRAINT name + | + ; + +returning_clause + : RETURNING target_list + | + ; + +// https://www.postgresql.org/docs/current/sql-merge.html +mergestmt + : MERGE INTO? qualified_name alias_clause? USING (select_with_parens | qualified_name) alias_clause? ON a_expr ( + merge_insert_clause merge_update_clause? + | merge_update_clause merge_insert_clause? + ) merge_delete_clause? + ; + +merge_insert_clause + : WHEN NOT MATCHED (AND a_expr)? THEN? INSERT (OPEN_PAREN insert_column_list CLOSE_PAREN)? values_clause + ; + +merge_update_clause + : WHEN MATCHED (AND a_expr)? THEN? UPDATE SET set_clause_list + ; + +merge_delete_clause + : WHEN MATCHED THEN? DELETE_P + ; + +deletestmt + : opt_with_clause DELETE_P FROM relation_expr_opt_alias using_clause where_or_current_clause returning_clause + ; + +using_clause + : USING from_list + | + ; + +lockstmt + : LOCK_P opt_table relation_expr_list opt_lock opt_nowait + ; + +opt_lock + : IN_P lock_type MODE + | + ; + +lock_type + : ACCESS (SHARE | EXCLUSIVE) + | ROW (SHARE | EXCLUSIVE) + | SHARE (UPDATE EXCLUSIVE | ROW EXCLUSIVE)? + | EXCLUSIVE + ; + +opt_nowait + : NOWAIT + | + ; + +opt_nowait_or_skip + : NOWAIT + | SKIP_P LOCKED + | + ; + +updatestmt + : opt_with_clause UPDATE relation_expr_opt_alias SET set_clause_list from_clause where_or_current_clause returning_clause + ; + +set_clause_list + : set_clause (COMMA set_clause)* + ; + +set_clause + : set_target EQUAL a_expr + | OPEN_PAREN set_target_list CLOSE_PAREN EQUAL a_expr + ; + +set_target + : colid opt_indirection + ; + +set_target_list + : set_target (COMMA set_target)* + ; + +declarecursorstmt + : DECLARE cursor_name cursor_options CURSOR opt_hold FOR selectstmt + ; + +cursor_name + : name + ; + +cursor_options + : (NO SCROLL | SCROLL | BINARY | INSENSITIVE)* + ; + +opt_hold + : + | WITH HOLD + | WITHOUT HOLD + ; + +/* +TODO: why select_with_parens alternative is needed at all? +i guess it because original byson grammar can choose selectstmt(2)->select_with_parens on only OPEN_PARENT/SELECT kewords at the begining of statement; +(select * from tab); +parse can go through selectstmt( )->select_no_parens(1)->select_clause(2)->select_with_parens(1)->select_no_parens(1)->select_clause(1)->simple_select +instead of selectstmt(1)->select_no_parens(1)->select_clause(2)->select_with_parens(1)->select_no_parens(1)->select_clause(1)->simple_select +all standard tests passed on both variants +*/ + +selectstmt + : select_no_parens + | select_with_parens + ; + +select_with_parens + : OPEN_PAREN select_no_parens CLOSE_PAREN + | OPEN_PAREN select_with_parens CLOSE_PAREN + ; + +select_no_parens + : select_clause opt_sort_clause ( + for_locking_clause opt_select_limit + | select_limit opt_for_locking_clause + )? + | with_clause select_clause opt_sort_clause ( + for_locking_clause opt_select_limit + | select_limit opt_for_locking_clause + )? + ; + +select_clause + : simple_select_intersect ((UNION | EXCEPT) all_or_distinct simple_select_intersect)* + ; + +simple_select_intersect + : simple_select_pramary (INTERSECT all_or_distinct simple_select_pramary)* + ; + +simple_select_pramary + : ( + SELECT (opt_all_clause into_clause opt_target_list | distinct_clause target_list | top_clause opt_target_list) into_clause from_clause where_clause group_clause + having_clause window_clause + ) + | values_clause + | TABLE relation_expr + | select_with_parens + ; + +top_clause + : TOP Integral + ; + +with_clause + : WITH RECURSIVE? cte_list + ; + +cte_list + : common_table_expr (COMMA common_table_expr)* + ; + +common_table_expr + : name opt_name_list AS opt_materialized OPEN_PAREN preparablestmt CLOSE_PAREN + ; + +opt_materialized + : MATERIALIZED + | NOT MATERIALIZED + | + ; + +opt_with_clause + : with_clause + | + ; + +into_clause + : INTO (opt_strict opttempTableName | into_target) + | + ; + +opt_strict + : + | STRICT_P + ; + +opttempTableName + : (LOCAL | GLOBAL)? (TEMPORARY | TEMP) opt_table qualified_name + | UNLOGGED opt_table qualified_name + | TABLE qualified_name + | qualified_name + ; + +opt_table + : TABLE + | + ; + +all_or_distinct + : ALL + | DISTINCT + | + ; + +distinct_clause + : DISTINCT (ON OPEN_PAREN expr_list CLOSE_PAREN)? + ; + +opt_all_clause + : ALL + | + ; + +opt_sort_clause + : sort_clause + | + ; + +sort_clause + : ORDER BY sortby_list + ; + +sortby_list + : sortby (COMMA sortby)* + ; + +sortby + : a_expr (USING qual_all_op | opt_asc_desc) opt_nulls_order + ; + +select_limit + : limit_clause offset_clause? + | offset_clause limit_clause? + ; + +opt_select_limit + : select_limit + | + ; + +limit_clause + : LIMIT select_limit_value (COMMA select_offset_value)? + | FETCH first_or_next ( + select_fetch_first_value row_or_rows (ONLY | WITH TIES) + | row_or_rows (ONLY | WITH TIES) + ) + ; + +offset_clause + : OFFSET (select_offset_value | select_fetch_first_value row_or_rows) + ; + +select_limit_value + : a_expr + | ALL + ; + +select_offset_value + : a_expr + ; + +select_fetch_first_value + : c_expr + | PLUS i_or_f_const + | MINUS i_or_f_const + ; + +i_or_f_const + : iconst + | fconst + ; + +row_or_rows + : ROW + | ROWS + ; + +first_or_next + : FIRST_P + | NEXT + ; + +group_clause + : GROUP_P BY group_by_list + | + ; + +group_by_list + : group_by_item (COMMA group_by_item)* + ; + +group_by_item + : empty_grouping_set + | cube_clause + | rollup_clause + | grouping_sets_clause + | a_expr + ; + +empty_grouping_set : OPEN_PAREN CLOSE_PAREN - | expr - | expr_list - | (ROLLUP | CUBE) OPEN_PAREN (expr | expr_list) (COMMA (expr | expr_list))* CLOSE_PAREN - | GROUPING SETS grouping_elem_list ; -grouping_elem_list - : OPEN_PAREN grouping_elem (COMMA grouping_elem)* CLOSE_PAREN +rollup_clause + : ROLLUP OPEN_PAREN expr_list CLOSE_PAREN + ; + +cube_clause + : CUBE OPEN_PAREN expr_list CLOSE_PAREN + ; + +grouping_sets_clause + : GROUPING SETS OPEN_PAREN group_by_list CLOSE_PAREN ; having_clause - : HAVING predicate (COMMA predicate)* + : HAVING a_expr + | ; -column_list - : ((column_name_=expr (AS? output_name=name_)?) | STAR) - (COMMA ((column_name_=expr (AS? output_name=name_)?) | STAR))* +for_locking_clause + : for_locking_items + | FOR READ ONLY ; -explain_parameter - : (ANALYZE | VERBOSE | COSTS | BUFFERS | TIMING) param_value? - | FORMAT (TEXT | XML | JSON | YAML) +opt_for_locking_clause + : for_locking_clause + | ; -frame - : UNBOUNDED PRECEDING - | parameterOrIntegerLiteral PRECEDING - | CURRENT ROW - | parameterOrIntegerLiteral FOLLOWING - | UNBOUNDED FOLLOWING +for_locking_items + : for_locking_item+ ; -frame_start - : frame +for_locking_item + : for_locking_strength locked_rels_list opt_nowait_or_skip ; -frame_end - : frame +for_locking_strength + : FOR ((NO KEY)? UPDATE | KEY? SHARE) ; -frame_clause - : (RANGE | ROWS) frame_start - | (RANGE | ROWS) BETWEEN frame_start AND frame_end +locked_rels_list + : OF qualified_name_list + | ; - -window_definition_list - : window_definition (COMMA window_definition)* + +values_clause + : VALUES OPEN_PAREN expr_list CLOSE_PAREN (COMMA OPEN_PAREN expr_list CLOSE_PAREN)* ; - -window_definition - : window_name AS window_specification + +from_clause + : FROM from_list + | + ; + +from_list + : non_ansi_join + | table_ref (COMMA table_ref)* + ; + +non_ansi_join + : table_ref (COMMA table_ref)+ + ; + +table_ref + : ( + relation_expr opt_alias_clause tablesample_clause? + | func_table func_alias_clause + | xmltable opt_alias_clause + | select_with_parens opt_alias_clause + | LATERAL_P ( + xmltable opt_alias_clause + | func_table func_alias_clause + | select_with_parens opt_alias_clause + ) + | OPEN_PAREN table_ref ( + CROSS JOIN table_ref + | NATURAL join_type? JOIN table_ref + | join_type? JOIN table_ref join_qual + )? CLOSE_PAREN opt_alias_clause + ) ( + CROSS JOIN table_ref + | NATURAL join_type? JOIN table_ref + | join_type? JOIN table_ref join_qual + )* + ; + +alias_clause + : AS? colid (OPEN_PAREN name_list CLOSE_PAREN)? + ; + +opt_alias_clause + : table_alias_clause + | + ; + +table_alias_clause + : AS? table_alias (OPEN_PAREN name_list CLOSE_PAREN)? + ; + +func_alias_clause + : alias_clause + | (AS colid? | colid) OPEN_PAREN tablefuncelementlist CLOSE_PAREN + | + ; + +join_type + : (FULL | LEFT | RIGHT | INNER_P) OUTER_P? + ; + +join_qual + : USING OPEN_PAREN name_list CLOSE_PAREN + | ON a_expr + ; + +relation_expr + : qualified_name STAR? + | ONLY (qualified_name | OPEN_PAREN qualified_name CLOSE_PAREN) + ; + +relation_expr_list + : relation_expr (COMMA relation_expr)* + ; + +relation_expr_opt_alias + : relation_expr (AS? colid)? + ; + +tablesample_clause + : TABLESAMPLE func_name OPEN_PAREN expr_list CLOSE_PAREN opt_repeatable_clause + ; + +opt_repeatable_clause + : REPEATABLE OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +func_table + : func_expr_windowless opt_ordinality + | ROWS FROM OPEN_PAREN rowsfrom_list CLOSE_PAREN opt_ordinality + ; + +rowsfrom_item + : func_expr_windowless opt_col_def_list + ; + +rowsfrom_list + : rowsfrom_item (COMMA rowsfrom_item)* + ; + +opt_col_def_list + : AS OPEN_PAREN tablefuncelementlist CLOSE_PAREN + | + ; + +//TODO WITH_LA was used + +opt_ordinality + : WITH ORDINALITY + | + ; + +where_clause + : WHERE a_expr + | + ; + +where_or_current_clause + : WHERE (CURRENT_P OF cursor_name | a_expr) + | + ; + +opttablefuncelementlist + : tablefuncelementlist + | + ; + +tablefuncelementlist + : tablefuncelement (COMMA tablefuncelement)* + ; + +tablefuncelement + : colid typename opt_collate_clause + ; + +xmltable + : XMLTABLE OPEN_PAREN ( + c_expr xmlexists_argument COLUMNS xmltable_column_list + | XMLNAMESPACES OPEN_PAREN xml_namespace_list CLOSE_PAREN COMMA c_expr xmlexists_argument COLUMNS xmltable_column_list + ) CLOSE_PAREN + ; + +xmltable_column_list + : xmltable_column_el (COMMA xmltable_column_el)* + ; + +xmltable_column_el + : colid (typename xmltable_column_option_list? | FOR ORDINALITY) + ; + +xmltable_column_option_list + : xmltable_column_option_el+ + ; + +xmltable_column_option_el + : DEFAULT a_expr + | identifier a_expr + | NOT NULL_P + | NULL_P + ; + +xml_namespace_list + : xml_namespace_el (COMMA xml_namespace_el)* + ; + +xml_namespace_el + : b_expr AS collabel + | DEFAULT b_expr + ; + +typename + : SETOF? simpletypename (opt_array_bounds | ARRAY (OPEN_BRACKET iconst CLOSE_BRACKET)?) + | qualified_name PERCENT (ROWTYPE | TYPE_P) + ; + +opt_array_bounds + : (OPEN_BRACKET iconst? CLOSE_BRACKET)* + ; + +simpletypename + : generictype + | numeric + | bit + | character + | constdatetime + | constinterval (opt_interval | OPEN_PAREN iconst CLOSE_PAREN) + ; + +consttypename + : numeric + | constbit + | constcharacter + | constdatetime + ; + +generictype + : (builtin_function_name | type_function_name | LEFT | RIGHT) attrs? opt_type_modifiers + ; + +opt_type_modifiers + : OPEN_PAREN expr_list CLOSE_PAREN + | + ; + +numeric + : INT_P + | INTEGER + | SMALLINT + | BIGINT + | REAL + | FLOAT_P opt_float + | DOUBLE_P PRECISION + | DECIMAL_P opt_type_modifiers + | DEC opt_type_modifiers + | NUMERIC opt_type_modifiers + | BOOLEAN_P + ; + +opt_float + : OPEN_PAREN iconst CLOSE_PAREN + | + ; + +//todo: merge alts + +bit + : bitwithlength + | bitwithoutlength + ; + +constbit + : bitwithlength + | bitwithoutlength + ; + +bitwithlength + : BIT opt_varying OPEN_PAREN expr_list CLOSE_PAREN + ; + +bitwithoutlength + : BIT opt_varying + ; + +character + : character_c (OPEN_PAREN iconst CLOSE_PAREN)? + ; + +constcharacter + : character_c (OPEN_PAREN iconst CLOSE_PAREN)? + ; + +character_c + : (CHARACTER | CHAR_P | NCHAR) opt_varying + | VARCHAR + | NATIONAL (CHARACTER | CHAR_P) opt_varying + ; + +opt_varying + : VARYING + | + ; + +constdatetime + : (TIMESTAMP | TIME) (OPEN_PAREN iconst CLOSE_PAREN)? opt_timezone + ; + +constinterval + : INTERVAL + ; + +//TODO with_la was used + +opt_timezone + : WITH TIME ZONE + | WITHOUT TIME ZONE + | + ; + +opt_interval + : YEAR_P + | MONTH_P + | DAY_P + | HOUR_P + | MINUTE_P + | interval_second + | YEAR_P TO MONTH_P + | DAY_P TO (HOUR_P | MINUTE_P | interval_second) + | HOUR_P TO (MINUTE_P | interval_second) + | MINUTE_P TO interval_second + | + ; + +interval_second + : SECOND_P (OPEN_PAREN iconst CLOSE_PAREN)? + ; + +opt_escape + : ESCAPE a_expr + | + ; + +//precendence accroding to Table 4.2. Operator Precedence (highest to lowest) + +//https://www.postgresql.org/docs/12/sql-syntax-lexical.html#SQL-PRECEDENCE + +/* +original version of a_expr, for info + a_expr: c_expr + //:: left PostgreSQL-style typecast + | a_expr TYPECAST typename -- 1 + | a_expr COLLATE any_name -- 2 + | a_expr AT TIME ZONE a_expr-- 3 + //right unary plus, unary minus + | (PLUS| MINUS) a_expr -- 4 + //left exponentiation + | a_expr CARET a_expr -- 5 + //left multiplication, division, modulo + | a_expr (STAR | SLASH | PERCENT) a_expr -- 6 + //left addition, subtraction + | a_expr (PLUS | MINUS) a_expr -- 7 + //left all other native and user-defined operators + | a_expr qual_op a_expr -- 8 + | qual_op a_expr -- 9 + //range containment, set membership, string matching BETWEEN IN LIKE ILIKE SIMILAR + | a_expr NOT? (LIKE|ILIKE|SIMILAR TO|(BETWEEN SYMMETRIC?)) a_expr opt_escape -- 10 + //< > = <= >= <> comparison operators + | a_expr (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr -- 11 + //IS ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS DISTINCT FROM, etc + | a_expr IS NOT? + ( + NULL_P + |TRUE_P + |FALSE_P + |UNKNOWN + |DISTINCT FROM a_expr + |OF OPEN_PAREN type_list CLOSE_PAREN + |DOCUMENT_P + |unicode_normal_form? NORMALIZED + ) -- 12 + | a_expr (ISNULL|NOTNULL) -- 13 + | row OVERLAPS row -- 14 + //NOT right logical negation + | NOT a_expr -- 15 + //AND left logical conjunction + | a_expr AND a_expr -- 16 + //OR left logical disjunction + | a_expr OR a_expr -- 17 + | a_expr (LESS_LESS|GREATER_GREATER) a_expr -- 18 + | a_expr qual_op -- 19 + | a_expr NOT? IN_P in_expr -- 20 + | a_expr subquery_Op sub_type (select_with_parens|OPEN_PAREN a_expr CLOSE_PAREN) -- 21 + | UNIQUE select_with_parens -- 22 + | DEFAULT -- 23 + | parameter +; +*/ + +a_expr + : a_expr_qual + ; + +/*23*/ + +/*moved to c_expr*/ + +/*22*/ + +/*moved to c_expr*/ + +/*19*/ + +a_expr_qual + : a_expr_lessless qual_op? + ; + +/*18*/ + +a_expr_lessless + : a_expr_or ((LESS_LESS | GREATER_GREATER) a_expr_or)* + ; + +/*17*/ + +a_expr_or + : a_expr_and (OR a_expr_and)* + ; + +/*16*/ + +a_expr_and + : a_expr_between (AND a_expr_between)* + ; + +/*21*/ + +a_expr_between + : a_expr_in (NOT? BETWEEN SYMMETRIC? a_expr_in AND a_expr_in)? + ; + +/*20*/ + +a_expr_in + : a_expr_unary_not (NOT? IN_P in_expr)? + ; + +/*15*/ + +a_expr_unary_not + : NOT? a_expr_isnull + ; + +/*14*/ + +/*moved to c_expr*/ + +/*13*/ + +a_expr_isnull + : a_expr_is_not (ISNULL | NOTNULL)? + ; + +/*12*/ + +a_expr_is_not + : a_expr_compare ( + IS NOT? ( + NULL_P + | TRUE_P + | FALSE_P + | UNKNOWN + | DISTINCT FROM a_expr + | OF OPEN_PAREN type_list CLOSE_PAREN + | DOCUMENT_P + | unicode_normal_form? NORMALIZED + ) + )? + ; + +/*11*/ + +a_expr_compare + : a_expr_like ( + (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr_like + | subquery_Op sub_type (select_with_parens | OPEN_PAREN a_expr CLOSE_PAREN) /*21*/ + )? + ; + +/*10*/ + +a_expr_like + : a_expr_qual_op (NOT? (LIKE | ILIKE | SIMILAR TO) a_expr_qual_op opt_escape)? + ; + +/* 8*/ + +a_expr_qual_op + : a_expr_unary_qualop (qual_op a_expr_unary_qualop)* + ; + +/* 9*/ + +a_expr_unary_qualop + : parameter + | qual_op? a_expr_add + ; + +/* 7*/ + +a_expr_add + : a_expr_mul ((MINUS | PLUS) a_expr_mul)* + ; + +/* 6*/ + +a_expr_mul + : a_expr_caret ((STAR | SLASH | PERCENT) a_expr_caret)* + ; + +/* 5*/ + +a_expr_caret + : a_expr_unary_sign (CARET a_expr)? + ; + +/* 4*/ + +a_expr_unary_sign + : (MINUS | PLUS)? a_expr_at_time_zone /* */ + ; + +/* 3*/ + +a_expr_at_time_zone + : a_expr_collate (AT TIME ZONE a_expr)? + ; + +/* 2*/ + +a_expr_collate + : a_expr_typecast (COLLATE any_name)? + ; + +/* 1*/ + +a_expr_typecast + : c_expr (TYPECAST typename)* + ; + +b_expr + : c_expr + | b_expr TYPECAST typename + //right unary plus, unary minus + | (PLUS | MINUS) b_expr + //^ left exponentiation + | b_expr CARET b_expr + //* / % left multiplication, division, modulo + | b_expr (STAR | SLASH | PERCENT) b_expr + //+ - left addition, subtraction + | b_expr (PLUS | MINUS) b_expr + //(any other operator) left all other native and user-defined operators + | b_expr qual_op b_expr + //< > = <= >= <> comparison operators + | b_expr (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) b_expr + | qual_op b_expr + | b_expr qual_op + //S ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS DISTINCT FROM, etc + | b_expr IS NOT? (DISTINCT FROM b_expr | OF OPEN_PAREN type_list CLOSE_PAREN | DOCUMENT_P) + ; + +c_expr + : EXISTS select_with_parens # c_expr_exists + | ARRAY (select_with_parens | array_expr) # c_expr_expr + | PARAM opt_indirection # c_expr_expr + | GROUPING OPEN_PAREN expr_list CLOSE_PAREN # c_expr_expr + | /*22*/ UNIQUE select_with_parens # c_expr_expr + | parameter # c_expr_expr + | columnref # c_expr_expr + | aexprconst # c_expr_expr + | OPEN_PAREN a_expr_in_parens = a_expr CLOSE_PAREN opt_indirection # c_expr_expr + | case_expr # c_expr_case + | func_expr # c_expr_expr + | select_with_parens indirection? # c_expr_expr + | explicit_row # c_expr_expr + | implicit_row # c_expr_expr + | row OVERLAPS row /* 14*/ # c_expr_expr + ; + +func_application + : func_name OPEN_PAREN ( + func_arg_list (COMMA VARIADIC func_arg_expr)? opt_sort_clause + | VARIADIC func_arg_expr opt_sort_clause + | (ALL | DISTINCT) func_arg_list opt_sort_clause + | STAR + | + ) CLOSE_PAREN + ; + +func_expr + : func_application within_group_clause filter_clause over_clause + | func_expr_common_subexpr + ; + +func_expr_windowless + : func_application + | func_expr_common_subexpr + ; + +func_expr_common_subexpr + : COLLATION FOR OPEN_PAREN a_expr CLOSE_PAREN + | CURRENT_DATE + | CURRENT_TIME (OPEN_PAREN iconst CLOSE_PAREN)? + | CURRENT_TIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | LOCALTIME (OPEN_PAREN iconst CLOSE_PAREN)? + | LOCALTIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | CURRENT_ROLE + | CURRENT_USER + | SESSION_USER + | USER + | CURRENT_CATALOG + | CURRENT_SCHEMA + | CAST OPEN_PAREN a_expr AS typename CLOSE_PAREN + | EXTRACT OPEN_PAREN extract_list CLOSE_PAREN + | NORMALIZE OPEN_PAREN a_expr (COMMA unicode_normal_form)? CLOSE_PAREN + | OVERLAY OPEN_PAREN overlay_list CLOSE_PAREN + | POSITION OPEN_PAREN position_list CLOSE_PAREN + | SUBSTRING OPEN_PAREN substr_list CLOSE_PAREN + | TREAT OPEN_PAREN a_expr AS typename CLOSE_PAREN + | TRIM OPEN_PAREN (BOTH | LEADING | TRAILING)? trim_list CLOSE_PAREN + | NULLIF OPEN_PAREN a_expr COMMA a_expr CLOSE_PAREN + | COALESCE OPEN_PAREN expr_list CLOSE_PAREN + | GREATEST OPEN_PAREN expr_list CLOSE_PAREN + | LEAST OPEN_PAREN expr_list CLOSE_PAREN + | XMLCONCAT OPEN_PAREN expr_list CLOSE_PAREN + | XMLELEMENT OPEN_PAREN NAME_P collabel (COMMA (xml_attributes | expr_list))? CLOSE_PAREN + | XMLEXISTS OPEN_PAREN c_expr xmlexists_argument CLOSE_PAREN + | XMLFOREST OPEN_PAREN xml_attribute_list CLOSE_PAREN + | XMLPARSE OPEN_PAREN document_or_content a_expr xml_whitespace_option CLOSE_PAREN + | XMLPI OPEN_PAREN NAME_P collabel (COMMA a_expr)? CLOSE_PAREN + | XMLROOT OPEN_PAREN XML_P a_expr COMMA xml_root_version opt_xml_root_standalone CLOSE_PAREN + | XMLSERIALIZE OPEN_PAREN document_or_content a_expr AS simpletypename CLOSE_PAREN + ; + +xml_root_version + : VERSION_P a_expr + | VERSION_P NO VALUE_P + ; + +opt_xml_root_standalone + : COMMA STANDALONE_P YES_P + | COMMA STANDALONE_P NO + | COMMA STANDALONE_P NO VALUE_P + | + ; + +xml_attributes + : XMLATTRIBUTES OPEN_PAREN xml_attribute_list CLOSE_PAREN + ; + +xml_attribute_list + : xml_attribute_el (COMMA xml_attribute_el)* + ; + +xml_attribute_el + : a_expr (AS collabel)? + ; + +document_or_content + : DOCUMENT_P + | CONTENT_P + ; + +xml_whitespace_option + : PRESERVE WHITESPACE_P + | STRIP_P WHITESPACE_P + | + ; + +xmlexists_argument + : PASSING c_expr + | PASSING c_expr xml_passing_mech + | PASSING xml_passing_mech c_expr + | PASSING xml_passing_mech c_expr xml_passing_mech + ; + +xml_passing_mech + : BY (REF | VALUE_P) + ; + +within_group_clause + : WITHIN GROUP_P OPEN_PAREN sort_clause CLOSE_PAREN + | + ; + +filter_clause + : FILTER OPEN_PAREN WHERE a_expr CLOSE_PAREN + | ; window_clause : WINDOW window_definition_list + | ; - -window_specification - : OPEN_PAREN window_name? partition_clause? order_by_clause? frame_clause? CLOSE_PAREN + +window_definition_list + : window_definition (COMMA window_definition)* ; - -partition_clause - : PARTITION BY expr (COMMA expr)* + +window_definition + : colid AS window_specification ; - + over_clause - : OVER (window_specification | window_name) + : OVER (window_specification | colid) + | ; -combine_clause - : ( UNION | INTERSECT | EXCEPT ) ( ALL | DISTINCT)? OPEN_PAREN* (select_stmt | values_stmt) CLOSE_PAREN* combine_clause? +window_specification + : OPEN_PAREN opt_existing_window_name opt_partition_clause opt_sort_clause opt_frame_clause CLOSE_PAREN ; -order_by_clause - : ORDER BY order_by_item (COMMA order_by_item)* +opt_existing_window_name + : colid + | ; -order_by_item - : (expr | DOUBLEQ_STRING_LITERAL) (ASC | DESC | USING expr)? ( (NULLS (FIRST | LAST)) (COMMA (NULLS (FIRST | LAST)))*)? +opt_partition_clause + : PARTITION BY expr_list + | ; -limit_clause - : LIMIT (parameterOrIntegerLiteral | ALL | func_call) +opt_frame_clause + : RANGE frame_extent opt_window_exclusion_clause + | ROWS frame_extent opt_window_exclusion_clause + | GROUPS frame_extent opt_window_exclusion_clause + | ; -offset_clause - : OFFSET parameterOrIntegerLiteral (ROW | ROWS)? +frame_extent + : frame_bound + | BETWEEN frame_bound AND frame_bound ; -fetch_clause - : FETCH (FIRST | NEXT) parameterOrIntegerLiteral? (ROW | ROWS) ONLY +frame_bound + : UNBOUNDED (PRECEDING | FOLLOWING) + | CURRENT_P ROW + | a_expr (PRECEDING | FOLLOWING) ; -for_clause - : FOR ( UPDATE | NO KEY UPDATE | SHARE | KEY SHARE ) (OF table_name_ (COMMA table_name_)*)? ( NOWAIT | SKIP_ LOCKED)* +opt_window_exclusion_clause + : EXCLUDE (CURRENT_P ROW | GROUP_P | TIES | NO OTHERS) + | ; -updater_clause - : updater_expr (COMMA updater_expr)* +row + : ROW OPEN_PAREN expr_list? CLOSE_PAREN + | OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN ; -updater_expr - : expr - | (OPEN_PAREN name_list CLOSE_PAREN EQUAL (expr | expr_list)) +explicit_row + : ROW OPEN_PAREN expr_list? CLOSE_PAREN ; -returning_clause - : RETURNING column_list +/* +TODO: +for some reason v1 +implicit_row: OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN; +works better than v2 +implicit_row: OPEN_PAREN expr_list CLOSE_PAREN; +while looks like they are almost the same, except v2 requieres at least 2 items in list +while v1 allows single item in list +*/ + +implicit_row + : OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN ; -// TODO: split into more granular expression types? -// TODO: handle operators like BETWEEN in a more normalized way -expr - : NULL +sub_type + : ANY + | SOME + | ALL + ; + +all_op + : Operator + | mathop + ; + +mathop + : PLUS + | MINUS + | STAR + | SLASH + | PERCENT + | CARET + | LT + | GT + | EQUAL + | LESS_EQUALS + | GREATER_EQUALS + | NOT_EQUALS + ; + +qual_op + : Operator + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + ; + +qual_all_op + : all_op + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + ; + +subquery_Op + : all_op + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + | LIKE + | NOT LIKE + | ILIKE + | NOT ILIKE + ; + +expr_list + : a_expr (COMMA a_expr)* + ; + +func_arg_list + : func_arg_expr (COMMA func_arg_expr)* + ; + +func_arg_expr + : a_expr + | param_name (COLON_EQUALS | EQUALS_GREATER) a_expr + ; + +type_list + : typename (COMMA typename)* + ; + +array_expr + : OPEN_BRACKET (expr_list | array_expr_list)? CLOSE_BRACKET + ; + +array_expr_list + : array_expr (COMMA array_expr)* + ; + +extract_list + : extract_arg FROM a_expr + | + ; + +extract_arg + : identifier + | YEAR_P + | MONTH_P + | DAY_P + | HOUR_P + | MINUTE_P + | SECOND_P + | sconst + ; + +unicode_normal_form + : NFC + | NFD + | NFKC + | NFKD + ; + +overlay_list + : a_expr PLACING a_expr FROM a_expr (FOR a_expr)? + ; + +position_list + : b_expr IN_P b_expr + | + ; + +substr_list + : a_expr FROM a_expr FOR a_expr + | a_expr FOR a_expr FROM a_expr + | a_expr FROM a_expr + | a_expr FOR a_expr + | a_expr SIMILAR a_expr ESCAPE a_expr + | expr_list + ; + +trim_list + : a_expr FROM expr_list + | FROM expr_list + | expr_list + ; + +in_expr + : select_with_parens # in_expr_select + | OPEN_PAREN expr_list CLOSE_PAREN # in_expr_list + ; + +case_expr + : CASE case_arg when_clause_list case_default END_P + ; + +when_clause_list + : when_clause+ + ; + +when_clause + : WHEN a_expr THEN a_expr + ; + +case_default + : ELSE a_expr + | + ; + +case_arg + : a_expr + | + ; + +columnref + : colid indirection? + ; + +indirection_el + : DOT (attr_name | STAR) + | OPEN_BRACKET (a_expr | opt_slice_bound COLON opt_slice_bound) CLOSE_BRACKET + ; + +opt_slice_bound + : a_expr + | + ; + +indirection + : indirection_el+ + ; + +opt_indirection + : indirection_el* + ; + +opt_target_list + : target_list + | + ; + +target_list + : target_el (COMMA target_el)* + ; + +target_el + : a_expr (AS collabel | identifier |) # target_label + | STAR # target_star + ; + +qualified_name_list + : qualified_name (COMMA qualified_name)* + ; + +qualified_name + : colid indirection? + ; + +name_list + : name (COMMA name)* + ; + +name + : colid + ; + +attr_name + : collabel + ; + +file_name + : sconst + ; + +func_name + : builtin_function_name + | type_function_name + | colid indirection + | LEFT + | RIGHT + ; + +aexprconst + : iconst + | fconst + | sconst + | bconst + | xconst + | func_name (sconst | OPEN_PAREN func_arg_list opt_sort_clause CLOSE_PAREN sconst) + | consttypename sconst + | constinterval (sconst opt_interval | OPEN_PAREN iconst CLOSE_PAREN sconst) + | TRUE_P + | FALSE_P + | NULL_P + ; + +xconst + : HexadecimalStringConstant + ; + +bconst + : BinaryStringConstant + ; + +fconst + : Numeric + ; + +iconst + : Integral + ; + +sconst + : anysconst opt_uescape + ; + +anysconst + : StringConstant + | UnicodeEscapeStringConstant + | BeginDollarStringConstant DollarText* EndDollarStringConstant + | EscapeStringConstant + ; + +opt_uescape + : UESCAPE anysconst + | + ; + +signediconst + : iconst + | PLUS iconst + | MINUS iconst + ; + +roleid + : rolespec + ; + +rolespec + : nonreservedword + | CURRENT_USER + | SESSION_USER + ; + +role_list + : rolespec (COMMA rolespec)* + ; + +colid + : identifier + | unreserved_keyword + | col_name_keyword + | plsql_unreserved_keyword + | LEFT + | RIGHT + ; + +table_alias + : identifier + | unreserved_keyword + | col_name_keyword + | plsql_unreserved_keyword + ; + +type_function_name + : identifier + | unreserved_keyword + | plsql_unreserved_keyword + | type_func_name_keyword + ; + +nonreservedword + : identifier + | unreserved_keyword + | col_name_keyword + | type_func_name_keyword + ; + +collabel + : identifier + | plsql_unreserved_keyword + | unreserved_keyword + | col_name_keyword + | type_func_name_keyword + | reserved_keyword + ; + +identifier + : Identifier opt_uescape + | QuotedIdentifier + | UnicodeQuotedIdentifier + | plsqlidentifier + | plsql_unreserved_keyword + ; + +plsqlidentifier + : PLSQLIDENTIFIER + ; + +unreserved_keyword + : ABORT_P + | ABSOLUTE_P + | ACCESS + | ACTION + | ADD_P + | ADMIN + | AFTER + | AGGREGATE + | ALSO + | ALTER + | ALWAYS + | ASSERTION + | ASSIGNMENT + | AT + | ATTACH + | ATTRIBUTE + | BACKWARD + | BEFORE + | BEGIN_P + | BY + | CACHE + | CALL + | CALLED + | CASCADE + | CASCADED + | CATALOG + | CHAIN + | CHARACTERISTICS + | CHECKPOINT + | CLASS + | CLOSE + | CLUSTER + | COLUMNS + | COMMENT + | COMMENTS + | COMMIT + | COMMITTED + | CONFIGURATION + | CONFLICT + | CONNECTION + | CONSTRAINTS + | CONTENT_P + | CONTINUE_P + | CONVERSION_P + | COPY + | COST + | CSV + | CUBE + | CURRENT_P + | CURSOR + | CYCLE + | DATA_P + | DATABASE + | DAY_P + | DEALLOCATE + | DECLARE + | DEFAULTS + | DEFERRED + | DEFINER + | DELETE_P + | DELIMITER + | DELIMITERS + | DEPENDS + | DETACH + | DICTIONARY + | DISABLE_P + | DISCARD + | DOCUMENT_P + | DOMAIN_P + | DOUBLE_P + | DROP + | EACH + | ENABLE_P + | ENCODING + | ENCRYPTED + | ENUM_P + | ESCAPE + | EVENT + | EXCLUDE + | EXCLUDING + | EXCLUSIVE + | EXECUTE + | EXPLAIN + | EXPRESSION + | EXTENSION + | EXTERNAL + | FAMILY + | FILTER + | FIRST_P + | FOLLOWING + | FORCE + | FORWARD + | FUNCTION + | FUNCTIONS + | GENERATED + | GLOBAL + | GRANTED + | GROUPS + | HANDLER + | HEADER_P + | HOLD + | HOUR_P + | IDENTITY_P + | IF_P + | IMMEDIATE + | IMMUTABLE + | IMPLICIT_P + | IMPORT_P + | INCLUDE + | INCLUDING + | INCREMENT + | INDEX + | INDEXES + | INHERIT + | INHERITS + | INLINE_P + | INPUT_P + | INSENSITIVE + | INSERT + | INSTEAD + | INVOKER + | ISOLATION + | KEY + | LABEL + | LANGUAGE + | LARGE_P + | LAST_P + | LEAKPROOF + | LEVEL + | LISTEN + | LOAD + | LOCAL + | LOCATION + | LOCK_P + | LOCKED + | LOGGED + | MAPPING + | MATCH + | MATERIALIZED + | MAXVALUE + | METHOD + | MINUTE_P + | MINVALUE + | MODE + | MONTH_P + | MOVE + | NAME_P + | NAMES + | NEW + | NEXT + | NFC + | NFD + | NFKC + | NFKD + | NO + | NORMALIZED + | NOTHING + | NOTIFY + | NOWAIT + | NULLS_P + | OBJECT_P + | OF + | OFF + | OIDS + | OLD + | OPERATOR + | OPTION + | OPTIONS + | ORDINALITY + | OTHERS + | OVER + | OVERRIDING + | OWNED + | OWNER + | PARALLEL + | PARSER + | PARTIAL + | PARTITION + | PASSING + | PASSWORD + | PLANS + | POLICY + | PRECEDING + | PREPARE + | PREPARED + | PRESERVE + | PRIOR + | PRIVILEGES + | PROCEDURAL + | PROCEDURE + | PROCEDURES + | PROGRAM + | PUBLICATION + | QUOTE + | RANGE + | READ + | REASSIGN + | RECHECK + | RECURSIVE + | REF + | REFERENCING + | REFRESH + | REINDEX + | RELATIVE_P + | RELEASE + | RENAME + | REPEATABLE + | REPLICA + | RESET + | RESTART + | RESTRICT + | RETURNS + | REVOKE + | ROLE + | ROLLBACK + | ROLLUP + | ROUTINE + | ROUTINES + | ROWS + | RULE + | SAVEPOINT + | SCHEMA + | SCHEMAS + | SCROLL + | SEARCH + | SECOND_P + | SECURITY + | SEQUENCE + | SEQUENCES + | SERIALIZABLE + | SERVER + | SESSION + | SET + | SETS + | SHARE + | SHOW + | SIMPLE + | SKIP_P + | SNAPSHOT + | SQL_P + | STABLE + | STANDALONE_P + | START + | STATEMENT + | STATISTICS + | STDIN + | STDOUT + | STORAGE + | STORED + | STRICT_P + | STRIP_P + | SUBSCRIPTION + | SUPPORT + | SYSID + | SYSTEM_P + | TABLES + | TABLESPACE + | TEMP + | TEMPLATE + | TEMPORARY + | TEXT_P + | TIES + | TRANSACTION + | TRANSFORM + | TRIGGER + | TRUNCATE + | TRUSTED + | TYPE_P + | TYPES_P + | UESCAPE + | UNBOUNDED + | UNCOMMITTED + | UNENCRYPTED + | UNKNOWN + | UNLISTEN + | UNLOGGED + | UNTIL + | UPDATE + | VACUUM + | VALID + | VALIDATE + | VALIDATOR + | VALUE_P + | VARYING + | VERSION_P + | VIEW + | VIEWS + | VOLATILE + | WHITESPACE_P + | WITHIN + | WITHOUT + | WORK + | WRAPPER + | WRITE + | XML_P + | YEAR_P + | YES_P + | ZONE + ; + +col_name_keyword + : BETWEEN + | BIGINT + | bit + | BOOLEAN_P + | CHAR_P + | character + | COALESCE + | DEC + | DECIMAL_P + | EXISTS + | EXTRACT + | FLOAT_P + | GREATEST + | GROUPING + | INOUT + | INT_P + | INTEGER + | INTERVAL + | LEAST + | NATIONAL + | NCHAR + | NONE + | NORMALIZE + | NULLIF + | numeric + | OUT_P + | OVERLAY + | POSITION + | PRECISION + | REAL + | ROW + | SETOF + | SMALLINT + | SUBSTRING + | TIME + | TIMESTAMP + | TREAT + | TRIM + | VALUES + | VARCHAR + | XMLATTRIBUTES + | XMLCONCAT + | XMLELEMENT + | XMLEXISTS + | XMLFOREST + | XMLNAMESPACES + | XMLPARSE + | XMLPI + | XMLROOT + | XMLSERIALIZE + | XMLTABLE + | builtin_function_name + ; + +type_func_name_keyword + : AUTHORIZATION + | BINARY + | COLLATION + | CONCURRENTLY + | CROSS + | CURRENT_SCHEMA + | FREEZE + | FULL + | ILIKE + | INNER_P + | IS + | ISNULL + | JOIN + | LIKE + | NATURAL + | NOTNULL + | OUTER_P + | OVERLAPS + | SIMILAR + | TABLESAMPLE + | VERBOSE + ; + +reserved_keyword + : ALL + | ANALYSE + | ANALYZE + | AND + | ANY + | ARRAY + | AS + | ASC + | ASYMMETRIC + | BOTH + | CASE + | CAST + | CHECK + | COLLATE + | COLUMN + | CONSTRAINT + | CREATE + | CURRENT_CATALOG | CURRENT_DATE | CURRENT_ROLE | CURRENT_TIME | CURRENT_TIMESTAMP | CURRENT_USER - | DEFAULT //used in insert_stmt in values - | INTEGER_LITERAL - | HEX_INTEGER_LITERAL // TODO: consolidate all integer literals under a rule - | NUMERIC_LITERAL - | SINGLEQ_STRING_LITERAL - | BIT_STRING - | REGEX_STRING - | DOLLAR_DOLLAR (~DOLLAR)+ DOLLAR_DOLLAR - | DOLLAR identifier (~DOLLAR)+ DOLLAR identifier DOLLAR - | bool_expr - | values_stmt + // | DEFAULT + | DEFERRABLE + | DESC + | DISTINCT + | DO + | ELSE + | END_P + | EXCEPT + | FALSE_P + | FETCH + | FOR + | FOREIGN + | FROM + | GRANT + | GROUP_P + | HAVING + | IN_P + | INITIALLY + | INTERSECT + /* +from pl_gram.y, line ~2982 + * Fortunately, INTO is a fully reserved word in the main grammar, so + * at least we need not worry about it appearing as an identifier. +*/ + + // | INTO + | LATERAL_P + | LEADING + | LIMIT + | LOCALTIME + | LOCALTIMESTAMP + | NOT + | NULL_P + | OFFSET + | ON + | ONLY + | OR + | ORDER + | PLACING + | PRIMARY + | REFERENCES + | RETURNING + | SELECT + | SESSION_USER + | SOME + | SYMMETRIC + | TABLE + | THEN + | TO + | TRAILING + | TRUE_P + | UNION + | UNIQUE + | USER + | USING + | VARIADIC + | WHEN + | WHERE + | WINDOW + | WITH + ; + +builtin_function_name + : XMLCOMMENT + | XML_IS_WELL_FORMED + | XML_IS_WELL_FORMED_DOCUMENT + | XML_IS_WELL_FORMED_CONTENT + | XMLAGG + | XPATH + | XPATH_EXISTS + | ABS + | CBRT + | CEIL + | CEILING + | DEGREES + | DIV + | EXP + | FACTORIAL + | FLOOR + | GCD + | LCM + | LN + | LOG + | LOG10 + | MIN_SCALE + | MOD + | PI + | POWER + | RADIANS + | ROUND + | SCALE + | SIGN + | SQRT + | TRIM_SCALE + | TRUNC + | WIDTH_BUCKET + | RANDOM + | SETSEED + | ACOS + | ACOSD + | ACOSH + | ASIN + | ASIND + | ASINH + | ATAN + | ATAND + | ATANH + | ATAN2 + | ATAN2D + | COS + | COSD + | COSH + | COT + | COTD + | SIN + | SIND + | SINH + | TAN + | TAND + | TANH + | BIT_LENGTH + | CHAR_LENGTH + | CHARACTER_LENGTH + | LOWER + | OCTET_LENGTH + | OCTET_LENGTH + | UPPER + | ASCII + | BTRIM + | CHR + | CONCAT + | CONCAT_WS + | FORMAT + | INITCAP + | LENGTH + | LPAD + | LTRIM + | MD5 + | PARSE_IDENT + | PG_CLIENT_ENCODING + | QUOTE_IDENT + | QUOTE_LITERAL + | QUOTE_NULLABLE + | REGEXP_COUNT + | REGEXP_INSTR + | REGEXP_LIKE + | REGEXP_MATCH + | REGEXP_MATCHES + | REGEXP_REPLACE + | REGEXP_SPLIT_TO_ARRAY + | REGEXP_SPLIT_TO_TABLE + | REGEXP_SUBSTR + | REPEAT + | REPLACE + | REVERSE + | RPAD + | RTRIM + | SPLIT_PART + | STARTS_WITH + | STRING_TO_ARRAY + | STRING_TO_TABLE + | STRPOS + | SUBSTR + | TO_ASCII + | TO_HEX + | TRANSLATE + | UNISTR + | AGE + | DATE_BIN + | DATE_PART + | DATE_TRUNC + | ISFINITE + | JUSTIFY_DAYS + | JUSTIFY_HOURS + | JUSTIFY_INTERVAL + | MAKE_DATE + | MAKE_INTERVAL + | MAKE_TIME + | MAKE_TIMESTAMP + | MAKE_TIMESTAMPTZ + | CLOCK_TIMESTAMP + | NOW + | STATEMENT_TIMESTAMP + | TIMEOFDAY + | TRANSACTION_TIMESTAMP + | TO_TIMESTAMP + | JUSTIFY_INTERVAL + | JUSTIFY_INTERVAL + | TO_CHAR + | TO_DATE + | TO_NUMBER + ; + +/************************************************************************************************************************************************************/ +/*PL/SQL GRAMMAR */ + +/*PLSQL grammar */ + +/************************************************************************************************************************************************************/ +pl_function + : comp_options pl_block opt_semi + ; + +comp_options + : comp_option* + ; + +comp_option + : sharp OPTION DUMP + | sharp PRINT_STRICT_PARAMS option_value + | sharp VARIABLE_CONFLICT ERROR + | sharp VARIABLE_CONFLICT USE_VARIABLE + | sharp VARIABLE_CONFLICT USE_COLUMN + ; + +sharp + : Operator + ; + +option_value + : sconst + | reserved_keyword + | plsql_unreserved_keyword + | unreserved_keyword + ; + +opt_semi + : + | SEMI + ; + +// exception_sect means opt_exception_sect in original grammar, don't be confused! + +pl_block + : decl_sect BEGIN_P proc_sect exception_sect END_P opt_label + ; + +decl_sect + : opt_block_label (decl_start decl_stmts?)? + ; + +decl_start + : DECLARE + ; + +decl_stmts + : decl_stmt+ + ; + +label_decl + : LESS_LESS any_identifier GREATER_GREATER + ; + +decl_stmt + : decl_statement + | DECLARE + | label_decl + ; + +decl_statement + : decl_varname ( + ALIAS FOR decl_aliasitem + | decl_const decl_datatype decl_collate decl_notnull decl_defval + | opt_scrollable CURSOR decl_cursor_args decl_is_for decl_cursor_query + ) SEMI + ; + +opt_scrollable + : + | NO SCROLL + | SCROLL + ; + +decl_cursor_query + : selectstmt + ; + +decl_cursor_args + : + | OPEN_PAREN decl_cursor_arglist CLOSE_PAREN + ; + +decl_cursor_arglist + : decl_cursor_arg (COMMA decl_cursor_arg)* + ; + +decl_cursor_arg + : decl_varname decl_datatype + ; + +decl_is_for + : IS + | FOR + ; + +decl_aliasitem + : PARAM + | colid + ; + +decl_varname + : any_identifier + ; + +decl_const + : + | CONSTANT + ; + +decl_datatype + : typename + ; //TODO: $$ = read_datatype(yychar); + +decl_collate + : + | COLLATE any_name + ; + +decl_notnull + : + | NOT NULL_P + ; + +decl_defval + : + | decl_defkey sql_expression + ; + +decl_defkey + : assign_operator + | DEFAULT + ; + +assign_operator + : EQUAL + | COLON_EQUALS + ; + +proc_sect + : proc_stmt* + ; + +proc_stmt + : pl_block SEMI + | stmt_return + | stmt_raise + | stmt_assign + | stmt_if + | stmt_case + | stmt_loop + | stmt_while + | stmt_for + | stmt_foreach_a + | stmt_exit + | stmt_assert + | stmt_execsql + | stmt_dynexecute + | stmt_perform + | stmt_call + | stmt_getdiag + | stmt_open + | stmt_fetch + | stmt_move + | stmt_close + | stmt_null + | stmt_commit + | stmt_rollback + | stmt_set + ; + +stmt_perform + : PERFORM expr_until_semi SEMI + ; + +stmt_call + : CALL any_identifier OPEN_PAREN opt_expr_list CLOSE_PAREN SEMI + | DO any_identifier OPEN_PAREN opt_expr_list CLOSE_PAREN SEMI + ; + +opt_expr_list + : | expr_list - // order of these terms implies order of operations - // see: https://www.postgresql.org/docs/10/static/sql-syntax-lexical.html#SQL-SYNTAX-OPERATORS - | expr OPEN_BRACKET expr CLOSE_BRACKET - | OPEN_PAREN expr CLOSE_PAREN - | type_name SINGLEQ_STRING_LITERAL - | op=(BANG_BANG | AT_SIGN | PLUS | MINUS) expr - | op=(TIL | QMARK_HYPHEN) expr - | expr op=BANG - | expr op=(CARET | PIPE_SLASH | PIPE_PIPE_SLASH) expr - | expr op=(STAR | SLASH | PERCENT) expr - | expr op=(PLUS | MINUS) expr - | expr op=( - AMP | PIPE | HASH | TIL | LT_LT | LT_LT_EQ | GT_GT | - AT_AT | LT_HYPHEN_GT | AT_GT | LT_AT | TIL_EQ | TIL_STAR| TIL_TIL | TIL_LT_TIL | TIL_GT_TIL | TIL_LTE_TIL | - TIL_GTE_TIL | LT_QMARK_GT | HYPHEN_GT | HYPHEN_GT_GT | HASH_HASH | HASH_GT | HASH_GT_GT | QMARK | QMARK_PIPE | - QMARK_AMP | QMARK_HASH | LT_CARET | AMP_LT | HYPHEN_PIPE_HYPHEN | HASH_EQ | AMP_AMP | PIPE_PIPE | EQUAL_GT | - NOT | AND | OR - ) expr - | expr (NOT LIKE | LIKE) expr //(STRING_LITERAL_SINGLE_Q | REGEX_STRING) - | expr NOT? BETWEEN expr AND expr - | expr (NOT IN | IN) expr - | expr op=(LT | GT | EQUAL | LTE | GTE | LT_GT | BANG_EQUAL) expr - | expr op=IS (bool_expr | NULL | NOT NULL) - | expr IS NOT? DISTINCT FROM expr - | op=(NOT | ALL ) expr - | func_call over_clause? - | identifier - | CAST OPEN_PAREN expr AS data_type CLOSE_PAREN - | correlation_name DOT column_name - | case_expr - | expr (OPEN_BRACKET expr? COLON expr? CLOSE_BRACKET)+ - | expr (COLON_COLON data_type)+ - | data_type expr - | expr IS OF OPEN_PAREN data_type CLOSE_PAREN - | expr DOT (identifier | STAR) - | aggregate // TODO: should there be a difference between an aggregate and a func_call? - | array_cons_expr - | expr (AT TIME ZONE) SINGLEQ_STRING_LITERAL // https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-ZONECONVERT - | EXISTS expr // NOT EXISTS will be in `op=(NOT | ALL) expr` - | DOLLAR_DEC - | OPEN_PAREN select_stmt CLOSE_PAREN - | parameter + ; + +stmt_assign + : assign_var assign_operator sql_expression SEMI + ; + +stmt_getdiag + : GET getdiag_area_opt DIAGNOSTICS getdiag_list SEMI + ; + +getdiag_area_opt + : + | CURRENT_P + | STACKED + ; + +getdiag_list + : getdiag_list_item (COMMA getdiag_list_item)* + ; + +getdiag_list_item + : getdiag_target assign_operator getdiag_item + ; + +getdiag_item + : colid + ; + +getdiag_target + : assign_var + ; + +assign_var + : (any_name | PARAM) (OPEN_BRACKET expr_until_rightbracket CLOSE_BRACKET)* + ; + +stmt_if + : IF_P expr_until_then THEN proc_sect stmt_elsifs stmt_else END_P IF_P SEMI + ; + +stmt_elsifs + : (ELSIF a_expr THEN proc_sect)* + ; + +stmt_else + : + | ELSE proc_sect + ; + +stmt_case + : CASE opt_expr_until_when case_when_list opt_case_else END_P CASE SEMI + ; + +opt_expr_until_when + : + | sql_expression + ; + +case_when_list + : case_when+ + ; + +case_when + : WHEN expr_list THEN proc_sect + ; + +opt_case_else + : + | ELSE proc_sect + ; + +stmt_loop + : opt_loop_label loop_body + ; + +stmt_while + : opt_loop_label WHILE expr_until_loop loop_body + ; + +stmt_for + : opt_loop_label FOR for_control loop_body + ; + +//TODO: rewrite using read_sql_expression logic? + +for_control + : for_variable IN_P ( + cursor_name opt_cursor_parameters + | selectstmt + | explainstmt + | EXECUTE a_expr opt_for_using_expression + | opt_reverse a_expr DOT_DOT a_expr opt_by_expression + ) + ; + +opt_for_using_expression + : + | USING expr_list + ; + +opt_cursor_parameters + : + | OPEN_PAREN a_expr (COMMA a_expr)* CLOSE_PAREN + ; + +opt_reverse + : + | REVERSE + ; + +opt_by_expression + : + | BY a_expr + ; + +for_variable + : any_name_list + ; + +stmt_foreach_a + : opt_loop_label FOREACH for_variable foreach_slice IN_P ARRAY a_expr loop_body + ; + +foreach_slice + : + | SLICE iconst + ; + +stmt_exit + : exit_type opt_label opt_exitcond SEMI + ; + +exit_type + : EXIT + | CONTINUE_P + ; + +//todo implement RETURN statement according to initial grammar line 1754 + +stmt_return + : RETURN ( + NEXT sql_expression + | QUERY (EXECUTE a_expr opt_for_using_expression | selectstmt) + | opt_return_result + ) SEMI + ; + +opt_return_result + : + | sql_expression + ; + +//https://www.postgresql.org/docs/current/plpgsql-errors-and-messages.html + +//RAISE [ level ] 'format' [, expression [, ... ]] [ USING option = expression [, ... ] ]; + +//RAISE [ level ] condition_name [ USING option = expression [, ... ] ]; + +//RAISE [ level ] SQLSTATE 'sqlstate' [ USING option = expression [, ... ] ]; + +//RAISE [ level ] USING option = expression [, ... ]; + +//RAISE ; + +stmt_raise + : RAISE opt_stmt_raise_level sconst opt_raise_list opt_raise_using SEMI + | RAISE opt_stmt_raise_level identifier opt_raise_using SEMI + | RAISE opt_stmt_raise_level SQLSTATE sconst opt_raise_using SEMI + | RAISE opt_stmt_raise_level opt_raise_using SEMI + | RAISE + ; + +opt_stmt_raise_level + : + | + | DEBUG + | LOG + | INFO + | NOTICE + | WARNING + | EXCEPTION + ; + +opt_raise_list + : + | (COMMA a_expr)+ + ; + +opt_raise_using + : + | USING opt_raise_using_elem_list + ; + +opt_raise_using_elem + : identifier EQUAL a_expr + ; + +opt_raise_using_elem_list + : opt_raise_using_elem (COMMA opt_raise_using_elem)* + ; + +//todo imnplement + +stmt_assert + : ASSERT sql_expression opt_stmt_assert_message SEMI + ; + +opt_stmt_assert_message + : + | COMMA sql_expression + ; + +loop_body + : LOOP proc_sect END_P LOOP opt_label SEMI + ; + +//TODO: looks like all other statements like INSERT/SELECT/UPDATE/DELETE are handled here; + +//pls take a look at original grammar + +stmt_execsql + : make_execsql_stmt SEMI + /*K_IMPORT + | K_INSERT + | t_word + | t_cword +*/ + ; + +//https://www.postgresql.org/docs/current/plpgsql-statements.html#PLPGSQL-STATEMENTS-SQL-NORESULT + +//EXECUTE command-string [ INTO [STRICT] target ] [ USING expression [, ... ] ]; + +stmt_dynexecute + : EXECUTE a_expr ( + /*this is silly, but i have to time to find nice way to code */ opt_execute_into opt_execute_using + | opt_execute_using opt_execute_into + | + ) SEMI + ; + +opt_execute_using + : + | USING opt_execute_using_list + ; + +opt_execute_using_list + : a_expr (COMMA a_expr)* + ; + +opt_execute_into + : + | INTO STRICT_P? into_target + ; + +//https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + +//OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR query; + +//OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR EXECUTE query_string + +// [ USING expression [, ... ] ]; + +//OPEN bound_cursorvar [ ( [ argument_name := ] argument_value [, ...] ) ]; + +stmt_open + : OPEN ( + cursor_variable opt_scroll_option FOR (selectstmt | EXECUTE sql_expression opt_open_using) + | colid (OPEN_PAREN opt_open_bound_list CLOSE_PAREN)? + ) SEMI + ; + +opt_open_bound_list_item + : colid COLON_EQUALS a_expr + | a_expr + ; + +opt_open_bound_list + : opt_open_bound_list_item (COMMA opt_open_bound_list_item)* + ; + +opt_open_using + : + | USING expr_list + ; + +opt_scroll_option + : + | opt_scroll_option_no SCROLL + ; + +opt_scroll_option_no + : + | NO + ; + +//https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + +//FETCH [ direction { FROM | IN } ] cursor INTO target; + +stmt_fetch + : FETCH direction = opt_fetch_direction opt_cursor_from cursor_variable INTO into_target SEMI + ; + +into_target + : expr_list + ; + +opt_cursor_from + : + | FROM + | IN_P + ; + +opt_fetch_direction + : + | + | NEXT + | PRIOR + | FIRST_P + | LAST_P + | ABSOLUTE_P a_expr + | RELATIVE_P a_expr + | a_expr + | ALL + | (FORWARD | BACKWARD) (a_expr | ALL)? + ; + +//https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + +//MOVE [ direction { FROM | IN } ] cursor; + +stmt_move + : MOVE opt_fetch_direction cursor_variable SEMI + ; + +stmt_close + : CLOSE cursor_variable SEMI + ; + +stmt_null + : NULL_P SEMI + ; + +stmt_commit + : COMMIT plsql_opt_transaction_chain SEMI + ; + +stmt_rollback + : ROLLBACK plsql_opt_transaction_chain SEMI + ; + +plsql_opt_transaction_chain + : AND NO? CHAIN + | + ; + +stmt_set + : SET any_name TO DEFAULT SEMI + | RESET (any_name | ALL) SEMI + ; + +cursor_variable + : colid + | PARAM + ; + +exception_sect + : + | EXCEPTION proc_exceptions + ; + +proc_exceptions + : proc_exception+ + ; + +proc_exception + : WHEN proc_conditions THEN proc_sect + ; + +proc_conditions + : proc_condition (OR proc_condition)* + ; + +proc_condition + : any_identifier + | SQLSTATE sconst + ; + +//expr_until_semi: + +//; + +//expr_until_rightbracket: + +//; + +//expr_until_loop: + +//; + +opt_block_label + : + | label_decl + ; + +opt_loop_label + : + | label_decl + ; + +opt_label + : + | any_identifier + ; + +opt_exitcond + : WHEN expr_until_semi + | + ; + +any_identifier + : colid + | plsql_unreserved_keyword + ; + +plsql_unreserved_keyword + : ABSOLUTE_P + | ALIAS + | AND + | ARRAY + | ASSERT + | BACKWARD + | CALL + | CHAIN + | CLOSE + | COLLATE + | COLUMN + //| COLUMN_NAME + | COMMIT + | CONSTANT + | CONSTRAINT + //| CONSTRAINT_NAME + | CONTINUE_P + | CURRENT_P + | CURSOR + //| DATATYPE + | DEBUG + | DEFAULT + //| DETAIL + | DIAGNOSTICS + | DO + | DUMP + | ELSIF + //| ERRCODE + | ERROR + | EXCEPTION + | EXIT + | FETCH + | FIRST_P + | FORWARD + | GET + //| HINT + + //| IMPORT + | INFO + | INSERT + | IS + | LAST_P + //| MESSAGE + + //| MESSAGE_TEXT + | MOVE + | NEXT + | NO + | NOTICE + | OPEN + | OPTION + | PERFORM + //| PG_CONTEXT + + //| PG_DATATYPE_NAME + + //| PG_EXCEPTION_CONTEXT + + //| PG_EXCEPTION_DETAIL + + //| PG_EXCEPTION_HINT + | PRINT_STRICT_PARAMS + | PRIOR + | QUERY + | RAISE + | RELATIVE_P + | RESET + | RETURN + //| RETURNED_SQLSTATE + | ROLLBACK + //| ROW_COUNT + | ROWTYPE + | SCHEMA + //| SCHEMA_NAME + | SCROLL + | SET + | SLICE + | SQLSTATE + | STACKED + | TABLE + //| TABLE_NAME + | TYPE_P + | USE_COLUMN + | USE_VARIABLE + | VARIABLE_CONFLICT + | WARNING + | OUTER_P + ; + +sql_expression + : opt_target_list into_clause from_clause where_clause group_clause having_clause window_clause + ; + +expr_until_then + : sql_expression + ; + +expr_until_semi + : sql_expression + ; + +expr_until_rightbracket + : a_expr + ; + +expr_until_loop + : a_expr + ; + +make_execsql_stmt + : stmt opt_returning_clause_into + ; + +opt_returning_clause_into + : INTO opt_strict into_target + | ; parameter : COLON SPEL - | COLON identifier - | COLON reserved_keyword - | COLON INTEGER_LITERAL - | prefix='?' SPEL - | prefix='?' INTEGER_LITERAL? + | COLON (colid | reserved_keyword) + | QUESTION SPEL + | QUESTION Integral ; - -parameterOrIntegerLiteral - : parameter - | INTEGER_LITERAL - ; - -parameterOrNumericLiteral - : parameter - | NUMERIC_LITERAL - ; - -// TODO: is this necessary. can we just encapsulate within expr's operator precedence? -bool_expr - : TRUE - | FALSE - | NOT bool_expr - | bool_expr AND bool_expr - | bool_expr OR bool_expr - ; - -case_expr - : CASE expr (WHEN expr THEN expr)+ (ELSE expr)? END - | CASE (WHEN predicate THEN expr)+ (ELSE expr)? END - ; - -expr_list - : OPEN_PAREN expr (COMMA expr)* CLOSE_PAREN - ; - -expr_list_list - : OPEN_PAREN? expr_list (COMMA expr_list)* CLOSE_PAREN? - ; - -func_sig_arg - : ((argmode=(IN|OUT|INOUT|VARIADIC))? (argname=identifier)? argtype=data_type)? - ; - -func_sig_arg_list - : func_sig_arg (COMMA func_sig_arg)* - ; - -func_sig - : name=identifier (OPEN_PAREN func_sig_arg_list CLOSE_PAREN)? - ; - -func_sig_list - : func_sig (COMMA func_sig)* - ; - -// TODO: rename prefix notation type casts -// Actual list on https://www.postgresql.org/docs/current/datatype.htm -type_name - : ABSTIME //obsolete, internal use only - | RELTIME //obsolete, internal use only - | BIGINT - | BIGSERIAL - | BIT (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | BIT_VARYING (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | BOOL - | BOOLEAN - | BOX - | BYTEA - | CHAR (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | CHARACTER (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | CHARACTER_VARYING (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | CIDR - | CIRCLE - | DATE - | DECIMAL (OPEN_PAREN INTEGER_LITERAL COMMA INTEGER_LITERAL CLOSE_PAREN)? - | DOUBLE PRECISION - | FLOAT4 - | FLOAT8 - | INET - | INT - | INT4 - | INT2 - | INT8 - | INTEGER - | INTERVAL FIELDS? (INTEGER_LITERAL)? - | JSON - | JSONB - | LINE - | LSEG - | MACADDR - | MACADDR8 - | MONEY - | NUMERIC (OPEN_PAREN INTEGER_LITERAL COMMA INTEGER_LITERAL CLOSE_PAREN)? - | PATH - | PG_LSN - | POINT - | POLYGON - | REAL - | SERIAL - | SERIAL2 - | SERIAL4 - | SERIAL8 - | SMALLINT - | SMALLSERIAL - | TEXT - | TIME (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? ((WITH|WITHOUT) TIME ZONE)? - | TIMESTAMP (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? ((WITH|WITHOUT) TIME ZONE)? - | TIMETZ (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | TIMESTAMPTZ (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | TSQUERY - | TSVECTOR - | TXID_SNAPSHOT - | UUID - | VARBIT (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | VARCHAR (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? - | XML - ; - -timezone - : SINGLEQ_STRING_LITERAL - | DOUBLEQ_STRING_LITERAL - | INTEGER_LITERAL - | NUMERIC_LITERAL - ; - -// TODO: what to do with this? -oper - : - | IS OF - | ALL - ; - -// TODO: explicit aggregate list or no? -// TODO: see test 27e55664.sql (create domain) for an example where a fn call isn't an aggregate -aggregate - : identifier OPEN_PAREN (ALL | DISTINCT)? expr (COMMA expr)* order_by_clause? CLOSE_PAREN - (FILTER OPEN_PAREN WHERE where_clause CLOSE_PAREN)? - | identifier OPEN_PAREN STAR CLOSE_PAREN (FILTER OPEN_PAREN WHERE where_clause CLOSE_PAREN)? - | identifier OPEN_PAREN (expr (COMMA expr)*)? CLOSE_PAREN WITHIN GROUP - OPEN_PAREN order_by_clause CLOSE_PAREN - (FILTER OPEN_PAREN WHERE where_clause CLOSE_PAREN)? - ; - -// TODO: rename aliases of [a-z]+_name to just name for clarity -name_ - : SINGLEQ_STRING_LITERAL - | identifier - ; - -name_list - : name_ (COMMA name_)* - ; - -identifier_list - : identifier (COMMA identifier)* - ; - -// TODD: should this be used outside -option_expr - : option_name=identifier (EQUAL value=param_value)? - ; - -option_list - : option_expr (COMMA option_expr)* - ; - -// TODO: remove -table_name_ - : identifier - ; - -// identifier used in create_domain_stmt as custom type -// Maybe need to add (OPEN_PAREN INTEGER_LITERAL CLOSE_PAREN)? after identifier for length of custom type -data_type - : (type_name|identifier) (OPEN_BRACKET INTEGER_LITERAL? CLOSE_BRACKET)* - ; - -data_type_list - : data_type (COMMA data_type)* - ; - -index_method - : builtin=(BTREE | HASH_ | GIST | SPGIST | GIN | BRIN) - | unknown=identifier - ; - -func_name - : identifier - ; - -func_call - : func_name OPEN_PAREN VARIADIC expr CLOSE_PAREN - | func_name OPEN_PAREN (expr (COMMA expr)* (COMMA VARIADIC expr)?)? CLOSE_PAREN - | func_name OPEN_PAREN todo_fill_in FROM expr (FOR expr)? CLOSE_PAREN - ; - -array_cons_expr - : ARRAY OPEN_BRACKET (expr (COMMA expr)*)? CLOSE_BRACKET - ; - -from_item - : ONLY? table_name_ STAR? with_column_alias? - (TABLESAMPLE todo_fill_in OPEN_PAREN expr (COMMA expr)* CLOSE_PAREN (REPEATABLE OPEN_PAREN todo_fill_in CLOSE_PAREN)?)? - | LATERAL? OPEN_PAREN stmt CLOSE_PAREN AS? alias (OPEN_PAREN column_alias (COMMA column_alias)* CLOSE_PAREN)? - | LATERAL? func_call (WITH ORDINALITY)? with_column_alias? - | LATERAL? func_call AS OPEN_PAREN column_definition (COMMA column_definition)* CLOSE_PAREN - | LATERAL? ROWS FROM OPEN_PAREN func_call CLOSE_PAREN - (AS OPEN_PAREN column_definition (COMMA column_definition)* CLOSE_PAREN)? CLOSE_PAREN - | from_item NATURAL? join_type OPEN_PAREN? from_item join_clause? CLOSE_PAREN? // TODO: fix 'left' being treated as an alias - ; - -with_column_alias - : AS? alias (column_alias (COMMA column_alias)*)? - | AS? alias OPEN_PAREN name_list CLOSE_PAREN - ; - -join_type - : INNER? JOIN - | LEFT OUTER? JOIN - | RIGHT OUTER? JOIN - | FULL OUTER? JOIN - | CROSS JOIN - ; - -join_clause - : ON predicate - | USING OPEN_PAREN column_name (COMMA column_name)* CLOSE_PAREN // TODO: consolidate column_name (,column_name *) into its own production - ; - -// TODO: fill in -// TODO: have explicity binary operator completion? -predicate - : expr - | expr oper expr - | OPEN_PAREN predicate CLOSE_PAREN - | predicate AND predicate - | predicate OR predicate - | NOT predicate - ; - -aggregate_signature - : STAR - // TODO: can we combine the two using the ? operator - | (argmode=(IN|VARIADIC))? (argname=identifier)? argtype=data_type_list - | ((argmode=(IN|VARIADIC))? (argname=identifier)? argtype=data_type_list) - ORDER BY (argmode=(IN|VARIADIC))? (argname=identifier)? argtype=data_type_list - ; - -column_constraint - : NOT NULL; - -column_constraints - : column_constraint+ - ; - -index_parameters - : (WITH OPEN_PAREN option_list CLOSE_PAREN)? (USING INDEX TABLESPACE tablespace=identifier)? - ; - -exclude_element - : (column_name_=identifier | OPEN_PAREN expr CLOSE_PAREN) (opclass=identifier)? (ASC | DESC)? (NULLS (FIRST | LAST))? - ; - -table_constraint - : (CONSTRAINT constraint_name=name_)? - ( (CHECK OPEN_PAREN expr CLOSE_PAREN (NO INHERIT)?) - | (UNIQUE OPEN_PAREN columns=identifier_list CLOSE_PAREN) - | (PRIMARY KEY OPEN_PAREN columns=identifier_list CLOSE_PAREN index_parameters) - | (EXCLUDE (USING index_method)? OPEN_PAREN exclude_element WITH operators=identifier_list CLOSE_PAREN index_parameters (WHERE OPEN_PAREN predicate CLOSE_PAREN))? - | (FOREIGN KEY OPEN_PAREN columns=identifier_list CLOSE_PAREN REFERENCES reftable=identifier (columns=identifier_list)? - (MATCH FULL | MATCH PARTIAL | MATCH_SIMPLE)? (ON DELETE action=identifier)? (ON UPDATE action=identifier)?) - ) - (NOT? DEFERABLE)? (INITIALLY (DEFERRED|IMMEDIATE))? - ; - -role_name - : name=name_ | CURRENT_USER | SESSION_USER | PUBLIC - ; - -role_name_list - : role_name (COMMA role_name)* - ; - -param_value - : ON | OFF | TRUE | FALSE | YES | NO | NONE - | SINGLEQ_STRING_LITERAL - | parameterOrNumericLiteral - | parameterOrIntegerLiteral - | identifier - ; - -reserved_keyword - : CREATE | DROP | FROM | GROUP | LIMIT | ORDER | SELECT | UNION - ; - -// allow non-reserved keywords as identifiers -// TODO: is this necessary? -// easier to whitelist than blacklist -non_reserved_keyword - : A_ | ABORT | ABS | ABSOLUTE | ACCESS - | ACTION | ADA | ADD | ADMIN | AFTER - | AGGREGATE | ALLOCATE | ALSO | ALTER | ALWAYS | ANY - | ARE | ASENSITIVE | ASSERTION | ASSIGNMENT | AT - | ATOMIC | ATTRIBUTE | ATTRIBUTES | AVG | BACKWARD - | BEFORE | BEGIN | BERNOULLI | BETWEEN | BIGINT - | BIT | BIT_LENGTH | BLOB | BOOLEAN | BREADTH - | BY | C_ | CACHE | CALL | CALLED - | CARDINALITY | CASCADE | CASCADED | CATALOG | CATALOG_NAME - | CEIL | CEILING | CHAIN | CHAR | CHARACTER - | CHARACTERISTICS | CHARACTERS | CHARACTER_LENGTH | CHARACTER_SET_CATALOG | CHARACTER_SET_NAME - | CHARACTER_SET_SCHEMA | CHAR_LENGTH | CHECKPOINT | CLASS | CLASS_ORIGIN - | CLOB | CLOSE | CLUSTER | COALESCE | COBOL - | COLLATION_CATALOG | COLLATION_NAME | COLLATION_SCHEMA | COLLECT | COLUMN_NAME - | COMMAND_FUNCTION | COMMAND_FUNCTION_CODE | COMMENT | COMMIT | COMMITTED - | CONDITION | CONDITION_NUMBER | CONNECT | CONNECTION | CONNECTION_NAME - | CONSTRAINTS | CONSTRAINT_CATALOG | CONSTRAINT_NAME | CONSTRAINT_SCHEMA | CONSTRUCTOR - | CONTAINS | CONTINUE | CONVERSION | CONVERT | COPY - | CORR | CORRESPONDING | COUNT | COVAR_POP | COVAR_SAMP - | CSV | CUBE | CUME_DIST | CURRENT | CURRENT_DEFAULT_TRANSFORM_GROUP - | CURRENT_PATH | CURRENT_TRANSFORM_GROUP_FOR_TYPE | CURSOR | CURSOR_NAME | CYCLE - | DATA | DATABASE | DATE | DATETIME_INTERVAL_CODE | DATETIME_INTERVAL_PRECISION - | DAY | DEALLOCATE | DEC | DECIMAL | DECLARE - | DEFAULTS | DEFERRED | DEFINED | DEFINER | DEGREE - | DELETE | DELIMITER | DELIMITERS | DENSE_RANK | DEPTH - | DEREF | DERIVED | DESCRIBE | DESCRIPTOR | DETERMINISTIC - | DIAGNOSTICS | DICTIONARY | DISCONNECT | DISPATCH | DOMAIN - | DOUBLE | DYNAMIC | DYNAMIC_FUNCTION | DYNAMIC_FUNCTION_CODE - | EACH | ELEMENT | ENCODING | ENCRYPTED | END - | EQUALS | ESCAPE | EVERY | EXCEPTION | EXCLUDE - | EXCLUDING | EXCLUSIVE | EXEC | EXECUTE | EXISTS - | EXP | EXPLAIN | EXTENSION | EXTERNAL | EXTRACT | FILTER - | FINAL | FIRST | FLOAT | FLOOR | FOLLOWING - | FORCE | FORMAT | FORTRAN | FORWARD | FOUND | FREE - | FUNCTION | FUSION | G_ | GENERAL | GENERATED - | GET | GLOBAL | GO | GOTO | GREATEST | GRANTED - | GROUPING | HANDLER | HIERARCHY | HOLD | HOST | HOUR - | IDENTITY | IGNORE | IMMEDIATE | IMMUTABLE | IMPLEMENTATION - | IMPLICIT | INCLUDING | INCREMENT | INDEX | INDICATOR - | INHERITS | INOUT | INPUT | INSENSITIVE | INSERT - | INSTANCE | INSTANTIABLE | INSTEAD | INT | INTEGER - | INTERSECTION | INTERVAL | INVOKER | ISOLATION | K_ - | KEY | KEY_MEMBER | KEY_TYPE | LANGUAGE | LARGE - | LAST | LEAST | LEFT | LENGTH | LEVEL | LISTEN | LN - | LOAD | LOCAL | LOCATION | LOCATOR | LOCK - | LOCKED | LOWER | M_ | MAP | MATCH - | MATCHED | MAX | MAXVALUE | MEMBER | MERGE - | MESSAGE_LENGTH | MESSAGE_OCTET_LENGTH | MESSAGE_TEXT | METHOD | MIN - | MINUTE | MINVALUE | MOD | MODE | MODIFIES - | MODULE | MONTH | MORE_ | MOVE | MULTISET - | MUMPS | NAME | NAMES | NATIONAL | NCHAR - | NCLOB | NESTING | NEW | NEXT | NO - | NONE | NORMALIZE | NORMALIZED | NOTHING | NOTIFY - | NOWAIT | NULLABLE | NULLIF | NULLS | NUMBER - | NUMERIC | OBJECT | OCTETS | OCTET_LENGTH | OF - | OFF | OIDS | OLD | OPEN | OPERATOR - | OPTION | OPTIONS | ORDERING | ORDINALITY | OTHERS - | OUT | OUTPUT | OVER | OVERLAY | OVERRIDING - | OWNER | PAD | PARAMETER | PARAMETER_MODE | PARAMETER_NAME - | PARAMETER_ORDINAL_POSITION | PARAMETER_SPECIFIC_CATALOG | PARAMETER_SPECIFIC_NAME | PARAMETER_SPECIFIC_SCHEMA - | PARTIAL | PARTITION | PASCAL | PASSWORD | PATH - | PERCENTILE_CONT | PERCENTILE_DISC | PERCENT_RANK | PLAIN | PLI | POSITION - | POWER | PRECEDING | PRECISION | PREPARE | PRESERVE - | PRIOR | PRIVILEGES | PROCEDURAL | PROCEDURE | PUBLIC - | QUOTE | RANGE | RANK | READ | READS - | REAL | RECHECK | RECURSIVE | REF | REFERENCING | REFRESH - | REGR_AVGX | REGR_AVGY | REGR_COUNT | REGR_INTERCEPT | REGR_SLOPE - | REGR_SXX | REGR_SXY | REGR_SYY | REINDEX | RELATIVE - | RELEASE | RENAME | REPEATABLE | REPLACE | RESET - | RESTART | RESTRICT | RESULT | RETURN | RETURNED_CARDINALITY - | RETURNED_LENGTH | RETURNED_OCTET_LENGTH | RETURNED_SQLSTATE | RETURNS | REVOKE - | RIGHT | ROLE | ROLLBACK | ROLLUP | ROUTINE | ROUTINE_CATALOG - | ROUTINE_NAME | ROUTINE_SCHEMA | ROW | ROWS | ROW_COUNT - | ROW_NUMBER | RULE | SAVEPOINT | SCALE | SCHEMA - | SCHEMA_NAME | SCOPE | SCOPE_CATALOG | SCOPE_NAME | SCOPE_SCHEMA - | SCROLL | SEARCH | SECOND | SECTION | SECURITY - | SELF | SENSITIVE | SEQUENCE | SEQUENCES | SERIALIZABLE | SERVER_NAME - | SESSION | SET | SETOF | SETS | SHARE - | SHOW | SIMPLE | SIZE | SMALLINT | SOME | SOURCE - | SPACE | SPECIFIC | SPECIFICTYPE | SPECIFIC_NAME | SQL - | SQLCODE | SQLERROR | SQLEXCEPTION | SQLSTATE | SQLWARNING - | SQRT | STABLE | START | STATE | STATEMENT - | STATIC | STATISTICS | STDDEV_POP | STDDEV_SAMP | STDIN - | STDOUT | STORAGE | STRICT | STRUCTURE | STYLE - | SUBCLASS_ORIGIN | SUBMULTISET | SUBSTRING | SUM | SYSID - | SYSTEM | SYSTEM_USER | TABLESPACE | TABLE_NAME - | TEMP | TEMPLATE | TEMPORARY | TEXT | TIES | TIME - | TIMESTAMP | TIMEZONE_HOUR | TIMEZONE_MINUTE | TOP | TOP_LEVEL_COUNT | TRANSACTION - | TRANSACTIONS_COMMITTED | TRANSACTIONS_ROLLED_BACK | TRANSACTION_ACTIVE | TRANSFORM | TRANSFORMS - | TRANSLATE | TRANSLATION | TREAT | TRIGGER | TRIGGER_CATALOG - | TRIGGER_NAME | TRIGGER_SCHEMA | TRIM | TRUE | TRUNCATE | TRUSTED - | TYPE | UESCAPE | UNBOUNDED | UNCOMMITTED | UNDER - | UNENCRYPTED | UNKNOWN | UNLISTEN | UNNAMED | UNNEST - | UNTIL | UPDATE | UPPER | USAGE | USER_DEFINED_TYPE_CATALOG - | USER_DEFINED_TYPE_CODE | USER_DEFINED_TYPE_NAME | USER_DEFINED_TYPE_SCHEMA | VACUUM | VALID - | VALIDATOR | VALUE | VALUES | VARCHAR | VARYING - | VAR_POP | VAR_SAMP | VERSION | VIEW | VOLATILE | WHENEVER - | WHITESPACE | WIDTH_BUCKET | WITHIN | WITHOUT | WORK - | WRITE | YEAR | ZONE - ; - -identifier - : non_reserved_keyword - | DOUBLEQ_STRING_LITERAL - | IDENTIFIER - | identifier DOT identifier - | type_name - | IDENTIFIER_UNICODE - ; - -todo_fill_in : . ; // TODO: Fill in with proper identification -todo_implement : identifier; -correlation_name : identifier; -// TODO: rename -column_name : identifier; -alias : identifier; -column_alias : identifier; -column_definition : identifier; -window_name : identifier; \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/LexerDispatchingErrorListener.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/LexerDispatchingErrorListener.java new file mode 100644 index 000000000..b361be81e --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/LexerDispatchingErrorListener.java @@ -0,0 +1,76 @@ +/* +PostgreSQL grammar. +The MIT License (MIT). +Copyright (c) 2021-2023, Oleksii Kovalov (Oleksii.Kovalov@outlook.com). +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ +package org.springframework.ide.vscode.parser.postgresql; + +import java.util.BitSet; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.*; + +public class LexerDispatchingErrorListener implements ANTLRErrorListener +{ + Lexer _parent; + + public LexerDispatchingErrorListener(Lexer parent) + { + _parent = parent; + } + + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) + { + ProxyErrorListener foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e); + } + + public void reportAmbiguity(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + boolean exact, + BitSet ambigAlts, + ATNConfigSet configs) + { + ProxyErrorListener foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs); + } + + public void reportAttemptingFullContext(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + BitSet conflictingAlts, + ATNConfigSet configs) + { + ProxyErrorListener foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs); + } + + public void reportContextSensitivity(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + int prediction, + ATNConfigSet configs) + { + ProxyErrorListener foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs); + } +} \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/ParserDispatchingErrorListener.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/ParserDispatchingErrorListener.java new file mode 100644 index 000000000..f4fa760c8 --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/ParserDispatchingErrorListener.java @@ -0,0 +1,76 @@ +/* +PostgreSQL grammar. +The MIT License (MIT). +Copyright (c) 2021-2023, Oleksii Kovalov (Oleksii.Kovalov@outlook.com). +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ +package org.springframework.ide.vscode.parser.postgresql; + +import java.util.BitSet; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.*; + +public class ParserDispatchingErrorListener implements ANTLRErrorListener +{ + Parser _parent; + + public ParserDispatchingErrorListener(Parser parent) + { + _parent = parent; + } + + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e); + } + + public void reportAmbiguity(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + boolean exact, + BitSet ambigAlts, + ATNConfigSet configs) + { + ProxyErrorListener foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs); + } + + public void reportAttemptingFullContext(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + BitSet conflictingAlts, + ATNConfigSet configs) + { + ProxyErrorListener foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs); + } + + public void reportContextSensitivity(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + int prediction, + ATNConfigSet configs) + { + ProxyErrorListener foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs); + } +} \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.java index 15ef11b20..5562c0de3 100644 --- a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.java +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.java @@ -1,5 +1,7 @@ // Generated from PostgreSqlLexer.g4 by ANTLR 4.13.1 package org.springframework.ide.vscode.parser.postgresql; + + import org.antlr.v4.runtime.Lexer; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.Token; @@ -10,521 +12,494 @@ import org.antlr.v4.runtime.dfa.DFA; import org.antlr.v4.runtime.misc.*; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) -public class PostgreSqlLexer extends Lexer { +public class PostgreSqlLexer extends PostgreSqlLexerBase { static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int - WHITESPACE=1, BLOCK_COMMENT=2, LINE_COMMENT=3, A_=4, ABORT=5, ABS=6, ABSOLUTE=7, - ACCESS=8, ACTION=9, ADA=10, ADD=11, ADMIN=12, AFTER=13, AGGREGATE=14, - ALIAS=15, ALL=16, ALLOCATE=17, ALSO=18, ALTER=19, ALWAYS=20, ANALYSE=21, - ANALYZE=22, AND=23, ANY=24, ARE=25, ARRAY=26, AS=27, ASC=28, ASENSITIVE=29, - ASSERTION=30, ASSIGNMENT=31, ASYMMETRIC=32, AT=33, ATOMIC=34, ATTRIBUTE=35, - ATTRIBUTES=36, AUTHORIZATION=37, AVG=38, BACKWARD=39, BEFORE=40, BEGIN=41, - BERNOULLI=42, BETWEEN=43, BIGINT=44, BINARY=45, BIT=46, BIT_LENGTH=47, - BITVAR=48, BLOB=49, BOOLEAN=50, BOTH=51, BREADTH=52, BUFFERS=53, BY=54, - C_=55, CACHE=56, CALL=57, CALLED=58, CARDINALITY=59, CASCADE=60, CASCADED=61, - CASE=62, CAST=63, CATALOG=64, CATALOG_NAME=65, CEIL=66, CEILING=67, CHAIN=68, - CHAR=69, CHAR_LENGTH=70, CHARACTER=71, CHARACTER_LENGTH=72, CHARACTER_SET_CATALOG=73, - CHARACTER_SET_NAME=74, CHARACTER_SET_SCHEMA=75, CHARACTERISTICS=76, CHARACTERS=77, - CHECK=78, CHECKED=79, CHECKPOINT=80, CLASS=81, CLASS_ORIGIN=82, CLOB=83, - CLOSE=84, CLUSTER=85, COALESCE=86, COBOL=87, COLLATE=88, COLLATION=89, - COLLATION_CATALOG=90, COLLATION_NAME=91, COLLATION_SCHEMA=92, COLLECT=93, - COLUMN=94, COLUMN_NAME=95, COMMAND_FUNCTION=96, COMMAND_FUNCTION_CODE=97, - COMMENT=98, COMMIT=99, COMMITTED=100, COMPLETION=101, CONDITION=102, CONDITION_NUMBER=103, - CONFIGURATION=104, CONFLICT=105, CONNECT=106, CONNECTION=107, CONNECTION_NAME=108, - CONSTRAINT=109, CONSTRAINT_CATALOG=110, CONSTRAINT_NAME=111, CONSTRAINT_SCHEMA=112, - CONSTRAINTS=113, CONSTRUCTOR=114, CONTAINS=115, CONTINUE=116, CONVERSION=117, - CONVERT=118, COPY=119, CORR=120, CORRESPONDING=121, COSTS=122, COUNT=123, - COVAR_POP=124, COVAR_SAMP=125, CREATE=126, CREATEDB=127, CREATEUSER=128, - CROSS=129, CSV=130, CUBE=131, CUME_DIST=132, CURRENT=133, CURRENT_DATE=134, - CURRENT_DEFAULT_TRANSFORM_GROUP=135, CURRENT_PATH=136, CURRENT_ROLE=137, - CURRENT_TIME=138, CURRENT_TIMESTAMP=139, CURRENT_TRANSFORM_GROUP_FOR_TYPE=140, - CURRENT_USER=141, CURSOR=142, CURSOR_NAME=143, CYCLE=144, DATA=145, DATABASE=146, - DATE=147, DATETIME_INTERVAL_CODE=148, DATETIME_INTERVAL_PRECISION=149, - DAY=150, DEALLOCATE=151, DEC=152, DECIMAL=153, DECLARE=154, DEFAULT=155, - DEFAULTS=156, DEFERABLE=157, DEFERRABLE=158, DEFERRED=159, DEFINED=160, - DEFINER=161, DEGREE=162, DELETE=163, DELIMITER=164, DELIMITERS=165, DENSE_RANK=166, - DEPENDS=167, DEPTH=168, DEREF=169, DERIVED=170, DESC=171, DESCRIBE=172, - DESCRIPTOR=173, DESTROY=174, DESTRUCTOR=175, DETERMINISTIC=176, DIAGNOSTICS=177, - DICTIONARY=178, DISABLE=179, DISABLE_PAGE_SKIPPING=180, DISCARD=181, DISCONNECT=182, - DISPATCH=183, DISTINCT=184, DO=185, DOMAIN=186, DOUBLE=187, DROP=188, - DYNAMIC=189, DYNAMIC_FUNCTION=190, DYNAMIC_FUNCTION_CODE=191, EACH=192, - ELEMENT=193, ELSE=194, ENABLE=195, ENCODING=196, ENCRYPTED=197, END=198, - END_EXEC=199, EQUALS=200, ESCAPE=201, EVERY=202, EXCEPT=203, EXCEPTION=204, - EXCLUDE=205, EXCLUDING=206, EXCLUSIVE=207, EXEC=208, EXECUTE=209, EXISTING=210, - EXISTS=211, EXP=212, EXPLAIN=213, EXTENDED=214, EXTENSION=215, EXTERNAL=216, - EXTRACT=217, FALSE=218, FETCH=219, FIELDS=220, FILTER=221, FINAL=222, - FIRST=223, FLOAT=224, FLOOR=225, FOLLOWING=226, FOR=227, FORCE=228, FOREIGN=229, - FORMAT=230, FORTRAN=231, FORWARD=232, FOUND=233, FREE=234, FREEZE=235, - FROM=236, FULL=237, FUNCTION=238, FUSION=239, G_=240, GENERAL=241, GENERATED=242, - GET=243, GLOBAL=244, GO=245, GOTO=246, GRANT=247, GRANTED=248, GREATEST=249, - GROUP=250, GROUPING=251, HANDLER=252, HAVING=253, HIERARCHY=254, HOLD=255, - HOST=256, HOUR=257, IDENTITY=258, IGNORE=259, ILIKE=260, IMMEDIATE=261, - IMMUTABLE=262, IMPLEMENTATION=263, IMPLICIT=264, IN=265, INCLUDING=266, - INCREMENT=267, INDEX=268, INDICATOR=269, INFIX=270, INHERITS=271, INITIALIZE=272, - INITIALLY=273, INNER=274, INOUT=275, INPUT=276, INSENSITIVE=277, INSERT=278, - INSTANCE=279, INSTANTIABLE=280, INSTEAD=281, INT=282, INTEGER=283, INTERSECT=284, - INTERSECTION=285, INTERVAL=286, INTO=287, INVOKER=288, IS=289, ISOLATION=290, - ITERATE=291, JOIN=292, K_=293, KEY=294, KEY_MEMBER=295, KEY_TYPE=296, - LABEL=297, LANCOMPILER=298, LANGUAGE=299, LARGE=300, LAST=301, LATERAL=302, - LEADING=303, LEAST=304, LEFT=305, LENGTH=306, LESS=307, LEVEL=308, LIKE=309, - LIMIT=310, LISTEN=311, LN=312, LOAD=313, LOCAL=314, LOCALTIME=315, LOCALTIMESTAMP=316, - LOCATION=317, LOCATOR=318, LOCK=319, LOCKED=320, LOWER=321, M_=322, MAIN=323, - MAP=324, MAPPING=325, MATCH=326, MATCH_SIMPLE=327, MATCHED=328, MAX=329, - MAXVALUE=330, MEMBER=331, MERGE=332, MESSAGE_LENGTH=333, MESSAGE_OCTET_LENGTH=334, - MESSAGE_TEXT=335, METHOD=336, MIN=337, MINUTE=338, MINVALUE=339, MOD=340, - MODE=341, MODIFIES=342, MODIFY=343, MODULE=344, MONTH=345, MORE_=346, - MOVE=347, MULTISET=348, MUMPS=349, NAME=350, NAMES=351, NATIONAL=352, - NATURAL=353, NCHAR=354, NCLOB=355, NESTING=356, NEW=357, NEXT=358, NO=359, - NOCREATEDB=360, NOCREATEUSER=361, NONE=362, NORMALIZE=363, NORMALIZED=364, - NOT=365, NOTHING=366, NOTIFY=367, NOTNULL=368, NOWAIT=369, NULL=370, NULLABLE=371, - NULLIF=372, NULLS=373, NUMBER=374, NUMERIC=375, OBJECT=376, OCTET_LENGTH=377, - OCTETS=378, OF=379, OFF=380, OFFSET=381, OIDS=382, OLD=383, ON=384, ONLY=385, - OPEN=386, OPERATION=387, OPERATOR=388, OPTION=389, OPTIONS=390, OR=391, - ORDER=392, ORDERING=393, ORDINALITY=394, OTHERS=395, OUT=396, OUTER=397, - OUTPUT=398, OVER=399, OVERLAPS=400, OVERLAY=401, OVERRIDING=402, OWNER=403, - PAD=404, PARAMETER=405, PARAMETER_MODE=406, PARAMETER_NAME=407, PARAMETER_ORDINAL_POSITION=408, - PARAMETER_SPECIFIC_CATALOG=409, PARAMETER_SPECIFIC_NAME=410, PARAMETER_SPECIFIC_SCHEMA=411, - PARAMETERS=412, PARSER=413, PARTIAL=414, PARTITION=415, PASCAL=416, PASSWORD=417, - PATH=418, PERCENT_RANK=419, PERCENTILE_CONT=420, PERCENTILE_DISC=421, - PLACING=422, PLAIN=423, PLANS=424, PLI=425, POSITION=426, POSTFIX=427, - POWER=428, PRECEDING=429, PRECISION=430, PREFIX=431, PREORDER=432, PREPARE=433, - PREPARED=434, PRESERVE=435, PRIMARY=436, PRIOR=437, PRIVILEGES=438, PROCEDURAL=439, - PROCEDURE=440, PUBLIC=441, PUBLICATION=442, QUOTE=443, RANGE=444, RANK=445, - READ=446, READS=447, REAL=448, REASSIGN=449, RECHECK=450, RECURSIVE=451, - REF=452, REFERENCES=453, REFERENCING=454, REFRESH=455, REGR_AVGX=456, - REGR_AVGY=457, REGR_COUNT=458, REGR_INTERCEPT=459, REGR_R2=460, REGR_SLOPE=461, - REGR_SXX=462, REGR_SXY=463, REGR_SYY=464, REINDEX=465, RELATIVE=466, RELEASE=467, - RENAME=468, REPEATABLE=469, REPLACE=470, REPLICA=471, RESET=472, RESTART=473, - RESTRICT=474, RESULT=475, RETURN=476, RETURNED_CARDINALITY=477, RETURNED_LENGTH=478, - RETURNED_OCTET_LENGTH=479, RETURNED_SQLSTATE=480, RETURNING=481, RETURNS=482, - REVOKE=483, RIGHT=484, ROLE=485, ROLLBACK=486, ROLLUP=487, ROUTINE=488, - ROUTINE_CATALOG=489, ROUTINE_NAME=490, ROUTINE_SCHEMA=491, ROW=492, ROW_COUNT=493, - ROW_NUMBER=494, ROWS=495, RULE=496, SAVEPOINT=497, SCALE=498, SCHEMA=499, - SCHEMA_NAME=500, SCOPE=501, SCOPE_CATALOG=502, SCOPE_NAME=503, SCOPE_SCHEMA=504, - SCROLL=505, SEARCH=506, SECOND=507, SECTION=508, SECURITY=509, SELECT=510, - SELF=511, SENSITIVE=512, SEQUENCE=513, SEQUENCES=514, SERIALIZABLE=515, - SERVER_NAME=516, SESSION=517, SESSION_USER=518, SET=519, SETOF=520, SETS=521, - SHARE=522, SHOW=523, SIMILAR=524, SIMPLE=525, SIZE=526, SKIP_=527, SMALLINT=528, - SNAPSHOT=529, SOME=530, SOURCE=531, SPACE=532, SPECIFIC=533, SPECIFIC_NAME=534, - SPECIFICTYPE=535, SQL=536, SQLCODE=537, SQLERROR=538, SQLEXCEPTION=539, - SQLSTATE=540, SQLWARNING=541, SQRT=542, STABLE=543, START=544, STATE=545, - STATEMENT=546, STATIC=547, STATISTICS=548, STDDEV_POP=549, STDDEV_SAMP=550, - STDIN=551, STDOUT=552, STORAGE=553, STRICT=554, STRUCTURE=555, STYLE=556, - SUBCLASS_ORIGIN=557, SUBLIST=558, SUBMULTISET=559, SUBSCRIPTION=560, SUBSTRING=561, - SUM=562, SYMMETRIC=563, SYSID=564, SYSTEM=565, SYSTEM_USER=566, TABLE=567, - TABLE_NAME=568, TABLESAMPLE=569, TABLESPACE=570, TEMP=571, TEMPLATE=572, - TEMPORARY=573, TERMINATE=574, THAN=575, THEN=576, TIES=577, TIME=578, - TIMESTAMP=579, TIMEZONE_HOUR=580, TIMEZONE_MINUTE=581, TIMING=582, TO=583, - TOAST=584, TOP=585, TOP_LEVEL_COUNT=586, TRAILING=587, TRANSACTION=588, - TRANSACTION_ACTIVE=589, TRANSACTIONS_COMMITTED=590, TRANSACTIONS_ROLLED_BACK=591, - TRANSFORM=592, TRANSFORMS=593, TRANSLATE=594, TRANSLATION=595, TREAT=596, - TRIGGER=597, TRIGGER_CATALOG=598, TRIGGER_NAME=599, TRIGGER_SCHEMA=600, - TRIM=601, TRUE=602, TRUNCATE=603, TRUSTED=604, TYPE=605, UESCAPE=606, - UNBOUNDED=607, UNCOMMITTED=608, UNDER=609, UNENCRYPTED=610, UNION=611, - UNIQUE=612, UNKNOWN=613, UNLISTEN=614, UNLOGGED=615, UNNAMED=616, UNNEST=617, - UNTIL=618, UPDATE=619, UPPER=620, USAGE=621, USER=622, USER_DEFINED_TYPE_CATALOG=623, - USER_DEFINED_TYPE_CODE=624, USER_DEFINED_TYPE_NAME=625, USER_DEFINED_TYPE_SCHEMA=626, - USING=627, VACUUM=628, VALID=629, VALIDATE=630, VALIDATOR=631, VALUE=632, - VALUES=633, VAR_POP=634, VAR_SAMP=635, VARCHAR=636, VARIABLE=637, VARIADIC=638, - VARYING=639, VERBOSE=640, VIEW=641, VOLATILE=642, WHEN=643, WHENEVER=644, - WHERE=645, WIDTH_BUCKET=646, WINDOW=647, WITH=648, WITHIN=649, WITHOUT=650, - WORK=651, WRITE=652, YAML=653, YEAR=654, YES=655, ZONE=656, SUPERUSER=657, - NOSUPERUSER=658, CREATEROLE=659, NOCREATEROLE=660, INHERIT=661, NOINHERIT=662, - LOGIN=663, NOLOGIN=664, REPLICATION=665, NOREPLICATION=666, BYPASSRLS=667, - NOBYPASSRLS=668, SFUNC=669, STYPE=670, SSPACE=671, FINALFUNC=672, FINALFUNC_EXTRA=673, - COMBINEFUNC=674, SERIALFUNC=675, DESERIALFUNC=676, INITCOND=677, MSFUNC=678, - MINVFUNC=679, MSTYPE=680, MSSPACE=681, MFINALFUNC=682, MFINALFUNC_EXTRA=683, - MINITCOND=684, SORTOP=685, PARALLEL=686, HYPOTHETICAL=687, SAFE=688, RESTRICTED=689, - UNSAFE=690, BASETYPE=691, IF=692, LOCALE=693, LC_COLLATE=694, LC_CTYPE=695, - PROVIDER=696, VERSION=697, ALLOW_CONNECTIONS=698, IS_TEMPLATE=699, EVENT=700, - WRAPPER=701, SERVER=702, BTREE=703, HASH_=704, GIST=705, SPGIST=706, GIN=707, - BRIN=708, CONCURRENTLY=709, INLINE=710, MATERIALIZED=711, LEFTARG=712, - RIGHTARG=713, COMMUTATOR=714, NEGATOR=715, HASHES=716, MERGES=717, FAMILY=718, - POLICY=719, OWNED=720, ABSTIME=721, BIGSERIAL=722, BIT_VARYING=723, BOOL=724, - BOX=725, BYTEA=726, CHARACTER_VARYING=727, CIDR=728, CIRCLE=729, FLOAT4=730, - FLOAT8=731, INET=732, INT2=733, INT4=734, INT8=735, JSON=736, JSONB=737, - LINE=738, LSEG=739, MACADDR=740, MACADDR8=741, MONEY=742, PG_LSN=743, - POINT=744, POLYGON=745, RELTIME=746, SERIAL=747, SERIAL2=748, SERIAL4=749, - SERIAL8=750, SMALLSERIAL=751, STSTEM=752, TEXT=753, TIMESTAMPTZ=754, TIMETZ=755, - TSQUERY=756, TSVECTOR=757, TXID_SNAPSHOT=758, UUID=759, VARBIT=760, XML=761, - COMMA=762, COLON=763, COLON_COLON=764, DOLLAR=765, DOLLAR_DOLLAR=766, - STAR=767, OPEN_PAREN=768, CLOSE_PAREN=769, OPEN_BRACKET=770, CLOSE_BRACKET=771, - BIT_STRING=772, REGEX_STRING=773, NUMERIC_LITERAL=774, INTEGER_LITERAL=775, - HEX_INTEGER_LITERAL=776, DOT=777, SINGLEQ_STRING_LITERAL=778, DOUBLEQ_STRING_LITERAL=779, - IDENTIFIER=780, DOLLAR_DEC=781, IDENTIFIER_UNICODE=782, AMP=783, AMP_AMP=784, - AMP_LT=785, AT_AT=786, AT_GT=787, AT_SIGN=788, BANG=789, BANG_BANG=790, - BANG_EQUAL=791, CARET=792, EQUAL=793, EQUAL_GT=794, GT=795, GTE=796, GT_GT=797, - HASH=798, HASH_EQ=799, HASH_GT=800, HASH_GT_GT=801, HASH_HASH=802, HYPHEN_GT=803, - HYPHEN_GT_GT=804, HYPHEN_PIPE_HYPHEN=805, LT=806, LTE=807, LT_AT=808, - LT_CARET=809, LT_GT=810, LT_HYPHEN_GT=811, LT_LT=812, LT_LT_EQ=813, LT_QMARK_GT=814, - MINUS=815, PERCENT=816, PIPE=817, PIPE_PIPE=818, PIPE_PIPE_SLASH=819, - PIPE_SLASH=820, PLUS=821, QMARK=822, QMARK_AMP=823, QMARK_HASH=824, QMARK_HYPHEN=825, - QMARK_PIPE=826, SLASH=827, TIL=828, TIL_EQ=829, TIL_GTE_TIL=830, TIL_GT_TIL=831, - TIL_LTE_TIL=832, TIL_LT_TIL=833, TIL_STAR=834, TIL_TIL=835, SEMI=836, - SPEL=837; + SPEL=1, Dollar=2, OPEN_PAREN=3, CLOSE_PAREN=4, OPEN_BRACKET=5, CLOSE_BRACKET=6, + COMMA=7, SEMI=8, COLON=9, QUESTION=10, STAR=11, EQUAL=12, DOT=13, PLUS=14, + MINUS=15, SLASH=16, CARET=17, LT=18, GT=19, LESS_LESS=20, GREATER_GREATER=21, + COLON_EQUALS=22, LESS_EQUALS=23, EQUALS_GREATER=24, GREATER_EQUALS=25, + DOT_DOT=26, NOT_EQUALS=27, TYPECAST=28, PERCENT=29, PARAM=30, Operator=31, + ALL=32, ANALYSE=33, ANALYZE=34, AND=35, ANY=36, ARRAY=37, AS=38, ASC=39, + ASYMMETRIC=40, BOTH=41, CASE=42, CAST=43, CHECK=44, COLLATE=45, COLUMN=46, + CONSTRAINT=47, CREATE=48, CURRENT_CATALOG=49, CURRENT_DATE=50, CURRENT_ROLE=51, + CURRENT_TIME=52, CURRENT_TIMESTAMP=53, CURRENT_USER=54, DEFAULT=55, DEFERRABLE=56, + DESC=57, DISTINCT=58, DO=59, ELSE=60, EXCEPT=61, FALSE_P=62, FETCH=63, + FOR=64, FOREIGN=65, FROM=66, GRANT=67, GROUP_P=68, HAVING=69, IN_P=70, + INITIALLY=71, INTERSECT=72, INTO=73, LATERAL_P=74, LEADING=75, LIMIT=76, + LOCALTIME=77, LOCALTIMESTAMP=78, NOT=79, NULL_P=80, OFFSET=81, ON=82, + ONLY=83, OR=84, ORDER=85, PLACING=86, PRIMARY=87, REFERENCES=88, RETURNING=89, + SELECT=90, SESSION_USER=91, SOME=92, SYMMETRIC=93, TABLE=94, THEN=95, + TO=96, TRAILING=97, TRUE_P=98, UNION=99, UNIQUE=100, USER=101, USING=102, + VARIADIC=103, WHEN=104, WHERE=105, WINDOW=106, WITH=107, AUTHORIZATION=108, + BINARY=109, COLLATION=110, CONCURRENTLY=111, CROSS=112, CURRENT_SCHEMA=113, + FREEZE=114, FULL=115, ILIKE=116, INNER_P=117, IS=118, ISNULL=119, JOIN=120, + LEFT=121, LIKE=122, NATURAL=123, NOTNULL=124, OUTER_P=125, OVER=126, OVERLAPS=127, + RIGHT=128, SIMILAR=129, VERBOSE=130, ABORT_P=131, ABSOLUTE_P=132, ACCESS=133, + ACTION=134, ADD_P=135, ADMIN=136, AFTER=137, AGGREGATE=138, ALSO=139, + ALTER=140, ALWAYS=141, ASSERTION=142, ASSIGNMENT=143, AT=144, ATTRIBUTE=145, + BACKWARD=146, BEFORE=147, BEGIN_P=148, BY=149, CACHE=150, CALLED=151, + CASCADE=152, CASCADED=153, CATALOG=154, CHAIN=155, CHARACTERISTICS=156, + CHECKPOINT=157, CLASS=158, CLOSE=159, CLUSTER=160, COMMENT=161, COMMENTS=162, + COMMIT=163, COMMITTED=164, CONFIGURATION=165, CONNECTION=166, CONSTRAINTS=167, + CONTENT_P=168, CONTINUE_P=169, CONVERSION_P=170, COPY=171, COST=172, CSV=173, + CURSOR=174, CYCLE=175, DATA_P=176, DATABASE=177, DAY_P=178, DEALLOCATE=179, + DECLARE=180, DEFAULTS=181, DEFERRED=182, DEFINER=183, DELETE_P=184, DELIMITER=185, + DELIMITERS=186, DICTIONARY=187, DISABLE_P=188, DISCARD=189, DOCUMENT_P=190, + DOMAIN_P=191, DOUBLE_P=192, DROP=193, EACH=194, ENABLE_P=195, ENCODING=196, + ENCRYPTED=197, ENUM_P=198, ESCAPE=199, EVENT=200, EXCLUDE=201, EXCLUDING=202, + EXCLUSIVE=203, EXECUTE=204, EXPLAIN=205, EXTENSION=206, EXTERNAL=207, + FAMILY=208, FIRST_P=209, FOLLOWING=210, FORCE=211, FORWARD=212, FUNCTION=213, + FUNCTIONS=214, GLOBAL=215, GRANTED=216, HANDLER=217, HEADER_P=218, HOLD=219, + HOUR_P=220, IDENTITY_P=221, IF_P=222, IMMEDIATE=223, IMMUTABLE=224, IMPLICIT_P=225, + INCLUDING=226, INCREMENT=227, INDEX=228, INDEXES=229, INHERIT=230, INHERITS=231, + INLINE_P=232, INSENSITIVE=233, INSERT=234, INSTEAD=235, INVOKER=236, ISOLATION=237, + KEY=238, LABEL=239, LANGUAGE=240, LARGE_P=241, LAST_P=242, LEAKPROOF=243, + LEVEL=244, LISTEN=245, LOAD=246, LOCAL=247, LOCATION=248, LOCK_P=249, + MAPPING=250, MATCH=251, MATCHED=252, MATERIALIZED=253, MAXVALUE=254, MERGE=255, + MINUTE_P=256, MINVALUE=257, MODE=258, MONTH_P=259, MOVE=260, NAME_P=261, + NAMES=262, NEXT=263, NO=264, NOTHING=265, NOTIFY=266, NOWAIT=267, NULLS_P=268, + OBJECT_P=269, OF=270, OFF=271, OIDS=272, OPERATOR=273, OPTION=274, OPTIONS=275, + OWNED=276, OWNER=277, PARSER=278, PARTIAL=279, PARTITION=280, PASSING=281, + PASSWORD=282, PLANS=283, PRECEDING=284, PREPARE=285, PREPARED=286, PRESERVE=287, + PRIOR=288, PRIVILEGES=289, PROCEDURAL=290, PROCEDURE=291, PROGRAM=292, + QUOTE=293, RANGE=294, READ=295, REASSIGN=296, RECHECK=297, RECURSIVE=298, + REF=299, REFRESH=300, REINDEX=301, RELATIVE_P=302, RELEASE=303, RENAME=304, + REPEATABLE=305, REPLACE=306, REPLICA=307, RESET=308, RESTART=309, RESTRICT=310, + RETURNS=311, REVOKE=312, ROLE=313, ROLLBACK=314, ROWS=315, RULE=316, SAVEPOINT=317, + SCHEMA=318, SCROLL=319, SEARCH=320, SECOND_P=321, SECURITY=322, SEQUENCE=323, + SEQUENCES=324, SERIALIZABLE=325, SERVER=326, SESSION=327, SET=328, SHARE=329, + SHOW=330, SIMPLE=331, SNAPSHOT=332, STABLE=333, STANDALONE_P=334, START=335, + STATEMENT=336, STATISTICS=337, STDIN=338, STDOUT=339, STORAGE=340, STRICT_P=341, + STRIP_P=342, SYSID=343, SYSTEM_P=344, TABLES=345, TABLESPACE=346, TEMP=347, + TEMPLATE=348, TEMPORARY=349, TEXT_P=350, TRANSACTION=351, TRIGGER=352, + TRUNCATE=353, TRUSTED=354, TYPE_P=355, TYPES_P=356, UNBOUNDED=357, UNCOMMITTED=358, + UNENCRYPTED=359, UNKNOWN=360, UNLISTEN=361, UNLOGGED=362, UNTIL=363, UPDATE=364, + VACUUM=365, VALID=366, VALIDATE=367, VALIDATOR=368, VARYING=369, VERSION_P=370, + VIEW=371, VOLATILE=372, WHITESPACE_P=373, WITHOUT=374, WORK=375, WRAPPER=376, + WRITE=377, XML_P=378, YEAR_P=379, YES_P=380, ZONE=381, BETWEEN=382, BIGINT=383, + BIT=384, BOOLEAN_P=385, CHAR_P=386, CHARACTER=387, COALESCE=388, DEC=389, + DECIMAL_P=390, EXISTS=391, EXTRACT=392, FLOAT_P=393, GREATEST=394, INOUT=395, + INT_P=396, INTEGER=397, INTERVAL=398, LEAST=399, NATIONAL=400, NCHAR=401, + NONE=402, NULLIF=403, NUMERIC=404, OVERLAY=405, POSITION=406, PRECISION=407, + REAL=408, ROW=409, SETOF=410, SMALLINT=411, SUBSTRING=412, TIME=413, TIMESTAMP=414, + TREAT=415, TRIM=416, VALUES=417, VARCHAR=418, XMLATTRIBUTES=419, XMLCOMMENT=420, + XMLAGG=421, XML_IS_WELL_FORMED=422, XML_IS_WELL_FORMED_DOCUMENT=423, XML_IS_WELL_FORMED_CONTENT=424, + XPATH=425, XPATH_EXISTS=426, XMLCONCAT=427, XMLELEMENT=428, XMLEXISTS=429, + XMLFOREST=430, XMLPARSE=431, XMLPI=432, XMLROOT=433, XMLSERIALIZE=434, + CALL=435, CURRENT_P=436, ATTACH=437, DETACH=438, EXPRESSION=439, GENERATED=440, + LOGGED=441, STORED=442, INCLUDE=443, ROUTINE=444, TRANSFORM=445, IMPORT_P=446, + POLICY=447, METHOD=448, REFERENCING=449, NEW=450, OLD=451, VALUE_P=452, + SUBSCRIPTION=453, PUBLICATION=454, OUT_P=455, END_P=456, ROUTINES=457, + SCHEMAS=458, PROCEDURES=459, INPUT_P=460, SUPPORT=461, PARALLEL=462, SQL_P=463, + DEPENDS=464, OVERRIDING=465, CONFLICT=466, SKIP_P=467, LOCKED=468, TIES=469, + ROLLUP=470, CUBE=471, GROUPING=472, SETS=473, TABLESAMPLE=474, ORDINALITY=475, + XMLTABLE=476, COLUMNS=477, XMLNAMESPACES=478, ROWTYPE=479, NORMALIZED=480, + WITHIN=481, FILTER=482, GROUPS=483, OTHERS=484, NFC=485, NFD=486, NFKC=487, + NFKD=488, UESCAPE=489, VIEWS=490, NORMALIZE=491, DUMP=492, PRINT_STRICT_PARAMS=493, + VARIABLE_CONFLICT=494, ERROR=495, USE_VARIABLE=496, USE_COLUMN=497, ALIAS=498, + CONSTANT=499, PERFORM=500, GET=501, DIAGNOSTICS=502, STACKED=503, ELSIF=504, + WHILE=505, REVERSE=506, FOREACH=507, SLICE=508, EXIT=509, RETURN=510, + QUERY=511, RAISE=512, SQLSTATE=513, DEBUG=514, LOG=515, INFO=516, NOTICE=517, + WARNING=518, EXCEPTION=519, ASSERT=520, LOOP=521, OPEN=522, TOP=523, ABS=524, + CBRT=525, CEIL=526, CEILING=527, DEGREES=528, DIV=529, EXP=530, FACTORIAL=531, + FLOOR=532, GCD=533, LCM=534, LN=535, LOG10=536, MIN_SCALE=537, MOD=538, + PI=539, POWER=540, RADIANS=541, ROUND=542, SCALE=543, SIGN=544, SQRT=545, + TRIM_SCALE=546, TRUNC=547, WIDTH_BUCKET=548, RANDOM=549, SETSEED=550, + ACOS=551, ACOSD=552, ASIN=553, ASIND=554, ATAN=555, ATAND=556, ATAN2=557, + ATAN2D=558, COS=559, COSD=560, COT=561, COTD=562, SIN=563, SIND=564, TAN=565, + TAND=566, SINH=567, COSH=568, TANH=569, ASINH=570, ACOSH=571, ATANH=572, + BIT_LENGTH=573, CHAR_LENGTH=574, CHARACTER_LENGTH=575, LOWER=576, OCTET_LENGTH=577, + UPPER=578, ASCII=579, BTRIM=580, CHR=581, CONCAT=582, CONCAT_WS=583, FORMAT=584, + INITCAP=585, LENGTH=586, LPAD=587, LTRIM=588, MD5=589, PARSE_IDENT=590, + PG_CLIENT_ENCODING=591, QUOTE_IDENT=592, QUOTE_LITERAL=593, QUOTE_NULLABLE=594, + REGEXP_COUNT=595, REGEXP_INSTR=596, REGEXP_LIKE=597, REGEXP_MATCH=598, + REGEXP_MATCHES=599, REGEXP_REPLACE=600, REGEXP_SPLIT_TO_ARRAY=601, REGEXP_SPLIT_TO_TABLE=602, + REGEXP_SUBSTR=603, REPEAT=604, RPAD=605, RTRIM=606, SPLIT_PART=607, STARTS_WITH=608, + STRING_TO_ARRAY=609, STRING_TO_TABLE=610, STRPOS=611, SUBSTR=612, TO_ASCII=613, + TO_HEX=614, TRANSLATE=615, UNISTR=616, AGE=617, CLOCK_TIMESTAMP=618, DATE_BIN=619, + DATE_PART=620, DATE_TRUNC=621, ISFINITE=622, JUSTIFY_DAYS=623, JUSTIFY_HOURS=624, + JUSTIFY_INTERVAL=625, MAKE_DATE=626, MAKE_INTERVAL=627, MAKE_TIME=628, + MAKE_TIMESTAMP=629, MAKE_TIMESTAMPTZ=630, NOW=631, STATEMENT_TIMESTAMP=632, + TIMEOFDAY=633, TRANSACTION_TIMESTAMP=634, TO_TIMESTAMP=635, TO_CHAR=636, + TO_DATE=637, TO_NUMBER=638, Identifier=639, QuotedIdentifier=640, UnterminatedQuotedIdentifier=641, + InvalidQuotedIdentifier=642, InvalidUnterminatedQuotedIdentifier=643, + UnicodeQuotedIdentifier=644, UnterminatedUnicodeQuotedIdentifier=645, + InvalidUnicodeQuotedIdentifier=646, InvalidUnterminatedUnicodeQuotedIdentifier=647, + StringConstant=648, UnterminatedStringConstant=649, UnicodeEscapeStringConstant=650, + UnterminatedUnicodeEscapeStringConstant=651, BeginDollarStringConstant=652, + BinaryStringConstant=653, UnterminatedBinaryStringConstant=654, InvalidBinaryStringConstant=655, + InvalidUnterminatedBinaryStringConstant=656, HexadecimalStringConstant=657, + UnterminatedHexadecimalStringConstant=658, InvalidHexadecimalStringConstant=659, + InvalidUnterminatedHexadecimalStringConstant=660, Integral=661, NumericFail=662, + Numeric=663, PLSQLIDENTIFIER=664, Whitespace=665, Newline=666, LineComment=667, + BlockComment=668, UnterminatedBlockComment=669, MetaCommand=670, EndMetaCommand=671, + ErrorCharacter=672, EscapeStringConstant=673, UnterminatedEscapeStringConstant=674, + InvalidEscapeStringConstant=675, InvalidUnterminatedEscapeStringConstant=676, + DollarText=677, EndDollarStringConstant=678, AfterEscapeStringConstantWithNewlineMode_Continued=679; + public static final int + EscapeStringConstantMode=1, AfterEscapeStringConstantMode=2, AfterEscapeStringConstantWithNewlineMode=3, + DollarQuotedStringMode=4; public static String[] channelNames = { "DEFAULT_TOKEN_CHANNEL", "HIDDEN" }; public static String[] modeNames = { - "DEFAULT_MODE" + "DEFAULT_MODE", "EscapeStringConstantMode", "AfterEscapeStringConstantMode", + "AfterEscapeStringConstantWithNewlineMode", "DollarQuotedStringMode" }; private static String[] makeRuleNames() { return new String[] { - "WHITESPACE", "BLOCK_COMMENT", "LINE_COMMENT", "A", "B", "C", "D", "E", - "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", - "T", "U", "V", "W", "X", "Y", "Z", "HEX_DIGIT", "DEC_DIGIT", "DQUOTA_STRING", - "SQUOTA_STRING", "BQUOTA_STRING", "A_", "ABORT", "ABS", "ABSOLUTE", "ACCESS", - "ACTION", "ADA", "ADD", "ADMIN", "AFTER", "AGGREGATE", "ALIAS", "ALL", - "ALLOCATE", "ALSO", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE", "AND", "ANY", - "ARE", "ARRAY", "AS", "ASC", "ASENSITIVE", "ASSERTION", "ASSIGNMENT", - "ASYMMETRIC", "AT", "ATOMIC", "ATTRIBUTE", "ATTRIBUTES", "AUTHORIZATION", - "AVG", "BACKWARD", "BEFORE", "BEGIN", "BERNOULLI", "BETWEEN", "BIGINT", - "BINARY", "BIT", "BIT_LENGTH", "BITVAR", "BLOB", "BOOLEAN", "BOTH", "BREADTH", - "BUFFERS", "BY", "C_", "CACHE", "CALL", "CALLED", "CARDINALITY", "CASCADE", - "CASCADED", "CASE", "CAST", "CATALOG", "CATALOG_NAME", "CEIL", "CEILING", - "CHAIN", "CHAR", "CHAR_LENGTH", "CHARACTER", "CHARACTER_LENGTH", "CHARACTER_SET_CATALOG", - "CHARACTER_SET_NAME", "CHARACTER_SET_SCHEMA", "CHARACTERISTICS", "CHARACTERS", - "CHECK", "CHECKED", "CHECKPOINT", "CLASS", "CLASS_ORIGIN", "CLOB", "CLOSE", - "CLUSTER", "COALESCE", "COBOL", "COLLATE", "COLLATION", "COLLATION_CATALOG", - "COLLATION_NAME", "COLLATION_SCHEMA", "COLLECT", "COLUMN", "COLUMN_NAME", - "COMMAND_FUNCTION", "COMMAND_FUNCTION_CODE", "COMMENT", "COMMIT", "COMMITTED", - "COMPLETION", "CONDITION", "CONDITION_NUMBER", "CONFIGURATION", "CONFLICT", - "CONNECT", "CONNECTION", "CONNECTION_NAME", "CONSTRAINT", "CONSTRAINT_CATALOG", - "CONSTRAINT_NAME", "CONSTRAINT_SCHEMA", "CONSTRAINTS", "CONSTRUCTOR", - "CONTAINS", "CONTINUE", "CONVERSION", "CONVERT", "COPY", "CORR", "CORRESPONDING", - "COSTS", "COUNT", "COVAR_POP", "COVAR_SAMP", "CREATE", "CREATEDB", "CREATEUSER", - "CROSS", "CSV", "CUBE", "CUME_DIST", "CURRENT", "CURRENT_DATE", "CURRENT_DEFAULT_TRANSFORM_GROUP", - "CURRENT_PATH", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", - "CURRENT_TRANSFORM_GROUP_FOR_TYPE", "CURRENT_USER", "CURSOR", "CURSOR_NAME", - "CYCLE", "DATA", "DATABASE", "DATE", "DATETIME_INTERVAL_CODE", "DATETIME_INTERVAL_PRECISION", - "DAY", "DEALLOCATE", "DEC", "DECIMAL", "DECLARE", "DEFAULT", "DEFAULTS", - "DEFERABLE", "DEFERRABLE", "DEFERRED", "DEFINED", "DEFINER", "DEGREE", - "DELETE", "DELIMITER", "DELIMITERS", "DENSE_RANK", "DEPENDS", "DEPTH", - "DEREF", "DERIVED", "DESC", "DESCRIBE", "DESCRIPTOR", "DESTROY", "DESTRUCTOR", - "DETERMINISTIC", "DIAGNOSTICS", "DICTIONARY", "DISABLE", "DISABLE_PAGE_SKIPPING", - "DISCARD", "DISCONNECT", "DISPATCH", "DISTINCT", "DO", "DOMAIN", "DOUBLE", - "DROP", "DYNAMIC", "DYNAMIC_FUNCTION", "DYNAMIC_FUNCTION_CODE", "EACH", - "ELEMENT", "ELSE", "ENABLE", "ENCODING", "ENCRYPTED", "END", "END_EXEC", - "EQUALS", "ESCAPE", "EVERY", "EXCEPT", "EXCEPTION", "EXCLUDE", "EXCLUDING", - "EXCLUSIVE", "EXEC", "EXECUTE", "EXISTING", "EXISTS", "EXP", "EXPLAIN", - "EXTENDED", "EXTENSION", "EXTERNAL", "EXTRACT", "FALSE", "FETCH", "FIELDS", - "FILTER", "FINAL", "FIRST", "FLOAT", "FLOOR", "FOLLOWING", "FOR", "FORCE", - "FOREIGN", "FORMAT", "FORTRAN", "FORWARD", "FOUND", "FREE", "FREEZE", - "FROM", "FULL", "FUNCTION", "FUSION", "G_", "GENERAL", "GENERATED", "GET", - "GLOBAL", "GO", "GOTO", "GRANT", "GRANTED", "GREATEST", "GROUP", "GROUPING", - "HANDLER", "HAVING", "HIERARCHY", "HOLD", "HOST", "HOUR", "IDENTITY", - "IGNORE", "ILIKE", "IMMEDIATE", "IMMUTABLE", "IMPLEMENTATION", "IMPLICIT", - "IN", "INCLUDING", "INCREMENT", "INDEX", "INDICATOR", "INFIX", "INHERITS", - "INITIALIZE", "INITIALLY", "INNER", "INOUT", "INPUT", "INSENSITIVE", - "INSERT", "INSTANCE", "INSTANTIABLE", "INSTEAD", "INT", "INTEGER", "INTERSECT", - "INTERSECTION", "INTERVAL", "INTO", "INVOKER", "IS", "ISOLATION", "ITERATE", - "JOIN", "K_", "KEY", "KEY_MEMBER", "KEY_TYPE", "LABEL", "LANCOMPILER", - "LANGUAGE", "LARGE", "LAST", "LATERAL", "LEADING", "LEAST", "LEFT", "LENGTH", - "LESS", "LEVEL", "LIKE", "LIMIT", "LISTEN", "LN", "LOAD", "LOCAL", "LOCALTIME", - "LOCALTIMESTAMP", "LOCATION", "LOCATOR", "LOCK", "LOCKED", "LOWER", "M_", - "MAIN", "MAP", "MAPPING", "MATCH", "MATCH_SIMPLE", "MATCHED", "MAX", - "MAXVALUE", "MEMBER", "MERGE", "MESSAGE_LENGTH", "MESSAGE_OCTET_LENGTH", - "MESSAGE_TEXT", "METHOD", "MIN", "MINUTE", "MINVALUE", "MOD", "MODE", - "MODIFIES", "MODIFY", "MODULE", "MONTH", "MORE_", "MOVE", "MULTISET", - "MUMPS", "NAME", "NAMES", "NATIONAL", "NATURAL", "NCHAR", "NCLOB", "NESTING", - "NEW", "NEXT", "NO", "NOCREATEDB", "NOCREATEUSER", "NONE", "NORMALIZE", - "NORMALIZED", "NOT", "NOTHING", "NOTIFY", "NOTNULL", "NOWAIT", "NULL", - "NULLABLE", "NULLIF", "NULLS", "NUMBER", "NUMERIC", "OBJECT", "OCTET_LENGTH", - "OCTETS", "OF", "OFF", "OFFSET", "OIDS", "OLD", "ON", "ONLY", "OPEN", - "OPERATION", "OPERATOR", "OPTION", "OPTIONS", "OR", "ORDER", "ORDERING", - "ORDINALITY", "OTHERS", "OUT", "OUTER", "OUTPUT", "OVER", "OVERLAPS", - "OVERLAY", "OVERRIDING", "OWNER", "PAD", "PARAMETER", "PARAMETER_MODE", - "PARAMETER_NAME", "PARAMETER_ORDINAL_POSITION", "PARAMETER_SPECIFIC_CATALOG", - "PARAMETER_SPECIFIC_NAME", "PARAMETER_SPECIFIC_SCHEMA", "PARAMETERS", - "PARSER", "PARTIAL", "PARTITION", "PASCAL", "PASSWORD", "PATH", "PERCENT_RANK", - "PERCENTILE_CONT", "PERCENTILE_DISC", "PLACING", "PLAIN", "PLANS", "PLI", - "POSITION", "POSTFIX", "POWER", "PRECEDING", "PRECISION", "PREFIX", "PREORDER", - "PREPARE", "PREPARED", "PRESERVE", "PRIMARY", "PRIOR", "PRIVILEGES", - "PROCEDURAL", "PROCEDURE", "PUBLIC", "PUBLICATION", "QUOTE", "RANGE", - "RANK", "READ", "READS", "REAL", "REASSIGN", "RECHECK", "RECURSIVE", - "REF", "REFERENCES", "REFERENCING", "REFRESH", "REGR_AVGX", "REGR_AVGY", - "REGR_COUNT", "REGR_INTERCEPT", "REGR_R2", "REGR_SLOPE", "REGR_SXX", - "REGR_SXY", "REGR_SYY", "REINDEX", "RELATIVE", "RELEASE", "RENAME", "REPEATABLE", - "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", "RESULT", "RETURN", - "RETURNED_CARDINALITY", "RETURNED_LENGTH", "RETURNED_OCTET_LENGTH", "RETURNED_SQLSTATE", - "RETURNING", "RETURNS", "REVOKE", "RIGHT", "ROLE", "ROLLBACK", "ROLLUP", - "ROUTINE", "ROUTINE_CATALOG", "ROUTINE_NAME", "ROUTINE_SCHEMA", "ROW", - "ROW_COUNT", "ROW_NUMBER", "ROWS", "RULE", "SAVEPOINT", "SCALE", "SCHEMA", - "SCHEMA_NAME", "SCOPE", "SCOPE_CATALOG", "SCOPE_NAME", "SCOPE_SCHEMA", - "SCROLL", "SEARCH", "SECOND", "SECTION", "SECURITY", "SELECT", "SELF", - "SENSITIVE", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER_NAME", - "SESSION", "SESSION_USER", "SET", "SETOF", "SETS", "SHARE", "SHOW", "SIMILAR", - "SIMPLE", "SIZE", "SKIP_", "SMALLINT", "SNAPSHOT", "SOME", "SOURCE", - "SPACE", "SPECIFIC", "SPECIFIC_NAME", "SPECIFICTYPE", "SQL", "SQLCODE", - "SQLERROR", "SQLEXCEPTION", "SQLSTATE", "SQLWARNING", "SQRT", "STABLE", - "START", "STATE", "STATEMENT", "STATIC", "STATISTICS", "STDDEV_POP", - "STDDEV_SAMP", "STDIN", "STDOUT", "STORAGE", "STRICT", "STRUCTURE", "STYLE", - "SUBCLASS_ORIGIN", "SUBLIST", "SUBMULTISET", "SUBSCRIPTION", "SUBSTRING", - "SUM", "SYMMETRIC", "SYSID", "SYSTEM", "SYSTEM_USER", "TABLE", "TABLE_NAME", - "TABLESAMPLE", "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TERMINATE", - "THAN", "THEN", "TIES", "TIME", "TIMESTAMP", "TIMEZONE_HOUR", "TIMEZONE_MINUTE", - "TIMING", "TO", "TOAST", "TOP", "TOP_LEVEL_COUNT", "TRAILING", "TRANSACTION", - "TRANSACTION_ACTIVE", "TRANSACTIONS_COMMITTED", "TRANSACTIONS_ROLLED_BACK", - "TRANSFORM", "TRANSFORMS", "TRANSLATE", "TRANSLATION", "TREAT", "TRIGGER", - "TRIGGER_CATALOG", "TRIGGER_NAME", "TRIGGER_SCHEMA", "TRIM", "TRUE", - "TRUNCATE", "TRUSTED", "TYPE", "UESCAPE", "UNBOUNDED", "UNCOMMITTED", - "UNDER", "UNENCRYPTED", "UNION", "UNIQUE", "UNKNOWN", "UNLISTEN", "UNLOGGED", - "UNNAMED", "UNNEST", "UNTIL", "UPDATE", "UPPER", "USAGE", "USER", "USER_DEFINED_TYPE_CATALOG", - "USER_DEFINED_TYPE_CODE", "USER_DEFINED_TYPE_NAME", "USER_DEFINED_TYPE_SCHEMA", - "USING", "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VALUE", "VALUES", - "VAR_POP", "VAR_SAMP", "VARCHAR", "VARIABLE", "VARIADIC", "VARYING", - "VERBOSE", "VIEW", "VOLATILE", "WHEN", "WHENEVER", "WHERE", "WIDTH_BUCKET", - "WINDOW", "WITH", "WITHIN", "WITHOUT", "WORK", "WRITE", "YAML", "YEAR", - "YES", "ZONE", "SUPERUSER", "NOSUPERUSER", "CREATEROLE", "NOCREATEROLE", - "INHERIT", "NOINHERIT", "LOGIN", "NOLOGIN", "REPLICATION", "NOREPLICATION", - "BYPASSRLS", "NOBYPASSRLS", "SFUNC", "STYPE", "SSPACE", "FINALFUNC", - "FINALFUNC_EXTRA", "COMBINEFUNC", "SERIALFUNC", "DESERIALFUNC", "INITCOND", - "MSFUNC", "MINVFUNC", "MSTYPE", "MSSPACE", "MFINALFUNC", "MFINALFUNC_EXTRA", - "MINITCOND", "SORTOP", "PARALLEL", "HYPOTHETICAL", "SAFE", "RESTRICTED", - "UNSAFE", "BASETYPE", "IF", "LOCALE", "LC_COLLATE", "LC_CTYPE", "PROVIDER", - "VERSION", "ALLOW_CONNECTIONS", "IS_TEMPLATE", "EVENT", "WRAPPER", "SERVER", - "BTREE", "HASH_", "GIST", "SPGIST", "GIN", "BRIN", "CONCURRENTLY", "INLINE", - "MATERIALIZED", "LEFTARG", "RIGHTARG", "COMMUTATOR", "NEGATOR", "HASHES", - "MERGES", "FAMILY", "POLICY", "OWNED", "ABSTIME", "BIGSERIAL", "BIT_VARYING", - "BOOL", "BOX", "BYTEA", "CHARACTER_VARYING", "CIDR", "CIRCLE", "FLOAT4", - "FLOAT8", "INET", "INT2", "INT4", "INT8", "JSON", "JSONB", "LINE", "LSEG", - "MACADDR", "MACADDR8", "MONEY", "PG_LSN", "POINT", "POLYGON", "RELTIME", - "SERIAL", "SERIAL2", "SERIAL4", "SERIAL8", "SMALLSERIAL", "STSTEM", "TEXT", - "TIMESTAMPTZ", "TIMETZ", "TSQUERY", "TSVECTOR", "TXID_SNAPSHOT", "UUID", - "VARBIT", "XML", "COMMA", "COLON", "COLON_COLON", "DOLLAR", "DOLLAR_DOLLAR", - "STAR", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET", - "BIT_STRING", "REGEX_STRING", "NUMERIC_LITERAL", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", - "DOT", "SINGLEQ_STRING_LITERAL", "DOUBLEQ_STRING_LITERAL", "IDENTIFIER", - "DOLLAR_DEC", "IDENTIFIER_UNICODE", "AMP", "AMP_AMP", "AMP_LT", "AT_AT", - "AT_GT", "AT_SIGN", "BANG", "BANG_BANG", "BANG_EQUAL", "CARET", "EQUAL", - "EQUAL_GT", "GT", "GTE", "GT_GT", "HASH", "HASH_EQ", "HASH_GT", "HASH_GT_GT", - "HASH_HASH", "HYPHEN_GT", "HYPHEN_GT_GT", "HYPHEN_PIPE_HYPHEN", "LT", - "LTE", "LT_AT", "LT_CARET", "LT_GT", "LT_HYPHEN_GT", "LT_LT", "LT_LT_EQ", - "LT_QMARK_GT", "MINUS", "PERCENT", "PIPE", "PIPE_PIPE", "PIPE_PIPE_SLASH", - "PIPE_SLASH", "PLUS", "QMARK", "QMARK_AMP", "QMARK_HASH", "QMARK_HYPHEN", - "QMARK_PIPE", "SLASH", "TIL", "TIL_EQ", "TIL_GTE_TIL", "TIL_GT_TIL", - "TIL_LTE_TIL", "TIL_LT_TIL", "TIL_STAR", "TIL_TIL", "SEMI", "SPEL", "ANYTHING" + "SPEL", "ANYTHING", "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", + "CLOSE_BRACKET", "COMMA", "SEMI", "COLON", "QUESTION", "STAR", "EQUAL", + "DOT", "PLUS", "MINUS", "SLASH", "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", + "COLON_EQUALS", "LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", "DOT_DOT", + "NOT_EQUALS", "TYPECAST", "PERCENT", "PARAM", "Operator", "OperatorEndingWithPlusMinus", + "OperatorCharacter", "OperatorCharacterNotAllowPlusMinusAtEnd", "OperatorCharacterAllowPlusMinusAtEnd", + "ALL", "ANALYSE", "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", + "BOTH", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", + "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", + "CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE", + "EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP_P", + "HAVING", "IN_P", "INITIALLY", "INTERSECT", "INTO", "LATERAL_P", "LEADING", + "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL_P", "OFFSET", "ON", + "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", "REFERENCES", "RETURNING", + "SELECT", "SESSION_USER", "SOME", "SYMMETRIC", "TABLE", "THEN", "TO", + "TRAILING", "TRUE_P", "UNION", "UNIQUE", "USER", "USING", "VARIADIC", + "WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", "BINARY", "COLLATION", + "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", "FREEZE", "FULL", "ILIKE", + "INNER_P", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL", "NOTNULL", + "OUTER_P", "OVER", "OVERLAPS", "RIGHT", "SIMILAR", "VERBOSE", "ABORT_P", + "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE", + "ALSO", "ALTER", "ALWAYS", "ASSERTION", "ASSIGNMENT", "AT", "ATTRIBUTE", + "BACKWARD", "BEFORE", "BEGIN_P", "BY", "CACHE", "CALLED", "CASCADE", + "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", "CLASS", + "CLOSE", "CLUSTER", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "CONFIGURATION", + "CONNECTION", "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P", + "COPY", "COST", "CSV", "CURSOR", "CYCLE", "DATA_P", "DATABASE", "DAY_P", + "DEALLOCATE", "DECLARE", "DEFAULTS", "DEFERRED", "DEFINER", "DELETE_P", + "DELIMITER", "DELIMITERS", "DICTIONARY", "DISABLE_P", "DISCARD", "DOCUMENT_P", + "DOMAIN_P", "DOUBLE_P", "DROP", "EACH", "ENABLE_P", "ENCODING", "ENCRYPTED", + "ENUM_P", "ESCAPE", "EVENT", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", + "EXPLAIN", "EXTENSION", "EXTERNAL", "FAMILY", "FIRST_P", "FOLLOWING", + "FORCE", "FORWARD", "FUNCTION", "FUNCTIONS", "GLOBAL", "GRANTED", "HANDLER", + "HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE", + "IMPLICIT_P", "INCLUDING", "INCREMENT", "INDEX", "INDEXES", "INHERIT", + "INHERITS", "INLINE_P", "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", + "ISOLATION", "KEY", "LABEL", "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF", + "LEVEL", "LISTEN", "LOAD", "LOCAL", "LOCATION", "LOCK_P", "MAPPING", + "MATCH", "MATCHED", "MATERIALIZED", "MAXVALUE", "MERGE", "MINUTE_P", + "MINVALUE", "MODE", "MONTH_P", "MOVE", "NAME_P", "NAMES", "NEXT", "NO", + "NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", "OBJECT_P", "OF", "OFF", "OIDS", + "OPERATOR", "OPTION", "OPTIONS", "OWNED", "OWNER", "PARSER", "PARTIAL", + "PARTITION", "PASSING", "PASSWORD", "PLANS", "PRECEDING", "PREPARE", + "PREPARED", "PRESERVE", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", + "PROGRAM", "QUOTE", "RANGE", "READ", "REASSIGN", "RECHECK", "RECURSIVE", + "REF", "REFRESH", "REINDEX", "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE", + "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE", + "ROLE", "ROLLBACK", "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", + "SEARCH", "SECOND_P", "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", + "SERVER", "SESSION", "SET", "SHARE", "SHOW", "SIMPLE", "SNAPSHOT", "STABLE", + "STANDALONE_P", "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT", + "STORAGE", "STRICT_P", "STRIP_P", "SYSID", "SYSTEM_P", "TABLES", "TABLESPACE", + "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P", "TRANSACTION", "TRIGGER", + "TRUNCATE", "TRUSTED", "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED", + "UNENCRYPTED", "UNKNOWN", "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE", + "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VARYING", "VERSION_P", "VIEW", + "VOLATILE", "WHITESPACE_P", "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML_P", + "YEAR_P", "YES_P", "ZONE", "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P", "CHAR_P", + "CHARACTER", "COALESCE", "DEC", "DECIMAL_P", "EXISTS", "EXTRACT", "FLOAT_P", + "GREATEST", "INOUT", "INT_P", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", + "NCHAR", "NONE", "NULLIF", "NUMERIC", "OVERLAY", "POSITION", "PRECISION", + "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", "TIME", "TIMESTAMP", + "TREAT", "TRIM", "VALUES", "VARCHAR", "XMLATTRIBUTES", "XMLCOMMENT", + "XMLAGG", "XML_IS_WELL_FORMED", "XML_IS_WELL_FORMED_DOCUMENT", "XML_IS_WELL_FORMED_CONTENT", + "XPATH", "XPATH_EXISTS", "XMLCONCAT", "XMLELEMENT", "XMLEXISTS", "XMLFOREST", + "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE", "CALL", "CURRENT_P", + "ATTACH", "DETACH", "EXPRESSION", "GENERATED", "LOGGED", "STORED", "INCLUDE", + "ROUTINE", "TRANSFORM", "IMPORT_P", "POLICY", "METHOD", "REFERENCING", + "NEW", "OLD", "VALUE_P", "SUBSCRIPTION", "PUBLICATION", "OUT_P", "END_P", + "ROUTINES", "SCHEMAS", "PROCEDURES", "INPUT_P", "SUPPORT", "PARALLEL", + "SQL_P", "DEPENDS", "OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", + "ROLLUP", "CUBE", "GROUPING", "SETS", "TABLESAMPLE", "ORDINALITY", "XMLTABLE", + "COLUMNS", "XMLNAMESPACES", "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", + "GROUPS", "OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", "VIEWS", + "NORMALIZE", "DUMP", "PRINT_STRICT_PARAMS", "VARIABLE_CONFLICT", "ERROR", + "USE_VARIABLE", "USE_COLUMN", "ALIAS", "CONSTANT", "PERFORM", "GET", + "DIAGNOSTICS", "STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", "SLICE", + "EXIT", "RETURN", "QUERY", "RAISE", "SQLSTATE", "DEBUG", "LOG", "INFO", + "NOTICE", "WARNING", "EXCEPTION", "ASSERT", "LOOP", "OPEN", "TOP", "ABS", + "CBRT", "CEIL", "CEILING", "DEGREES", "DIV", "EXP", "FACTORIAL", "FLOOR", + "GCD", "LCM", "LN", "LOG10", "MIN_SCALE", "MOD", "PI", "POWER", "RADIANS", + "ROUND", "SCALE", "SIGN", "SQRT", "TRIM_SCALE", "TRUNC", "WIDTH_BUCKET", + "RANDOM", "SETSEED", "ACOS", "ACOSD", "ASIN", "ASIND", "ATAN", "ATAND", + "ATAN2", "ATAN2D", "COS", "COSD", "COT", "COTD", "SIN", "SIND", "TAN", + "TAND", "SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "BIT_LENGTH", + "CHAR_LENGTH", "CHARACTER_LENGTH", "LOWER", "OCTET_LENGTH", "UPPER", + "ASCII", "BTRIM", "CHR", "CONCAT", "CONCAT_WS", "FORMAT", "INITCAP", + "LENGTH", "LPAD", "LTRIM", "MD5", "PARSE_IDENT", "PG_CLIENT_ENCODING", + "QUOTE_IDENT", "QUOTE_LITERAL", "QUOTE_NULLABLE", "REGEXP_COUNT", "REGEXP_INSTR", + "REGEXP_LIKE", "REGEXP_MATCH", "REGEXP_MATCHES", "REGEXP_REPLACE", "REGEXP_SPLIT_TO_ARRAY", + "REGEXP_SPLIT_TO_TABLE", "REGEXP_SUBSTR", "REPEAT", "RPAD", "RTRIM", + "SPLIT_PART", "STARTS_WITH", "STRING_TO_ARRAY", "STRING_TO_TABLE", "STRPOS", + "SUBSTR", "TO_ASCII", "TO_HEX", "TRANSLATE", "UNISTR", "AGE", "CLOCK_TIMESTAMP", + "DATE_BIN", "DATE_PART", "DATE_TRUNC", "ISFINITE", "JUSTIFY_DAYS", "JUSTIFY_HOURS", + "JUSTIFY_INTERVAL", "MAKE_DATE", "MAKE_INTERVAL", "MAKE_TIME", "MAKE_TIMESTAMP", + "MAKE_TIMESTAMPTZ", "NOW", "STATEMENT_TIMESTAMP", "TIMEOFDAY", "TRANSACTION_TIMESTAMP", + "TO_TIMESTAMP", "TO_CHAR", "TO_DATE", "TO_NUMBER", "Identifier", "IdentifierStartChar", + "IdentifierChar", "StrictIdentifierChar", "QuotedIdentifier", "UnterminatedQuotedIdentifier", + "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier", "UnicodeQuotedIdentifier", + "UnterminatedUnicodeQuotedIdentifier", "InvalidUnicodeQuotedIdentifier", + "InvalidUnterminatedUnicodeQuotedIdentifier", "StringConstant", "UnterminatedStringConstant", + "BeginEscapeStringConstant", "UnicodeEscapeStringConstant", "UnterminatedUnicodeEscapeStringConstant", + "BeginDollarStringConstant", "Tag", "BinaryStringConstant", "UnterminatedBinaryStringConstant", + "InvalidBinaryStringConstant", "InvalidUnterminatedBinaryStringConstant", + "HexadecimalStringConstant", "UnterminatedHexadecimalStringConstant", + "InvalidHexadecimalStringConstant", "InvalidUnterminatedHexadecimalStringConstant", + "Integral", "NumericFail", "Numeric", "Digits", "PLSQLIDENTIFIER", "Whitespace", + "Newline", "LineComment", "BlockComment", "UnterminatedBlockComment", + "MetaCommand", "EndMetaCommand", "ErrorCharacter", "EscapeStringConstant", + "UnterminatedEscapeStringConstant", "EscapeStringText", "InvalidEscapeStringConstant", + "InvalidUnterminatedEscapeStringConstant", "InvalidEscapeStringText", + "AfterEscapeStringConstantMode_Whitespace", "AfterEscapeStringConstantMode_Newline", + "AfterEscapeStringConstantWithNewlineMode_Whitespace", "AfterEscapeStringConstantWithNewlineMode_Newline", + "AfterEscapeStringConstantWithNewlineMode_Continued", "DollarText", "EndDollarStringConstant" }; } public static final String[] ruleNames = makeRuleNames(); private static String[] makeLiteralNames() { return new String[] { + null, null, "'$'", "'('", "')'", "'['", "']'", "','", "';'", "':'", "'?'", + "'*'", "'='", "'.'", "'+'", "'-'", "'/'", "'^'", "'<'", "'>'", "'<<'", + "'>>'", "':='", "'<='", "'=>'", "'>='", "'..'", "'<>'", "'::'", "'%'", + null, null, "'ALL'", "'ANALYSE'", "'ANALYZE'", "'AND'", "'ANY'", "'ARRAY'", + "'AS'", "'ASC'", "'ASYMMETRIC'", "'BOTH'", "'CASE'", "'CAST'", "'CHECK'", + "'COLLATE'", "'COLUMN'", "'CONSTRAINT'", "'CREATE'", "'CURRENT_CATALOG'", + "'CURRENT_DATE'", "'CURRENT_ROLE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_USER'", "'DEFAULT'", "'DEFERRABLE'", "'DESC'", "'DISTINCT'", + "'DO'", "'ELSE'", "'EXCEPT'", "'FALSE'", "'FETCH'", "'FOR'", "'FOREIGN'", + "'FROM'", "'GRANT'", "'GROUP'", "'HAVING'", "'IN'", "'INITIALLY'", "'INTERSECT'", + "'INTO'", "'LATERAL'", "'LEADING'", "'LIMIT'", "'LOCALTIME'", "'LOCALTIMESTAMP'", + "'NOT'", "'NULL'", "'OFFSET'", "'ON'", "'ONLY'", "'OR'", "'ORDER'", "'PLACING'", + "'PRIMARY'", "'REFERENCES'", "'RETURNING'", "'SELECT'", "'SESSION_USER'", + "'SOME'", "'SYMMETRIC'", "'TABLE'", "'THEN'", "'TO'", "'TRAILING'", "'TRUE'", + "'UNION'", "'UNIQUE'", "'USER'", "'USING'", "'VARIADIC'", "'WHEN'", "'WHERE'", + "'WINDOW'", "'WITH'", "'AUTHORIZATION'", "'BINARY'", "'COLLATION'", "'CONCURRENTLY'", + "'CROSS'", "'CURRENT_SCHEMA'", "'FREEZE'", "'FULL'", "'ILIKE'", "'INNER'", + "'IS'", "'ISNULL'", "'JOIN'", "'LEFT'", "'LIKE'", "'NATURAL'", "'NOTNULL'", + "'OUTER'", "'OVER'", "'OVERLAPS'", "'RIGHT'", "'SIMILAR'", "'VERBOSE'", + "'ABORT'", "'ABSOLUTE'", "'ACCESS'", "'ACTION'", "'ADD'", "'ADMIN'", + "'AFTER'", "'AGGREGATE'", "'ALSO'", "'ALTER'", "'ALWAYS'", "'ASSERTION'", + "'ASSIGNMENT'", "'AT'", "'ATTRIBUTE'", "'BACKWARD'", "'BEFORE'", "'BEGIN'", + "'BY'", "'CACHE'", "'CALLED'", "'CASCADE'", "'CASCADED'", "'CATALOG'", + "'CHAIN'", "'CHARACTERISTICS'", "'CHECKPOINT'", "'CLASS'", "'CLOSE'", + "'CLUSTER'", "'COMMENT'", "'COMMENTS'", "'COMMIT'", "'COMMITTED'", "'CONFIGURATION'", + "'CONNECTION'", "'CONSTRAINTS'", "'CONTENT'", "'CONTINUE'", "'CONVERSION'", + "'COPY'", "'COST'", "'CSV'", "'CURSOR'", "'CYCLE'", "'DATA'", "'DATABASE'", + "'DAY'", "'DEALLOCATE'", "'DECLARE'", "'DEFAULTS'", "'DEFERRED'", "'DEFINER'", + "'DELETE'", "'DELIMITER'", "'DELIMITERS'", "'DICTIONARY'", "'DISABLE'", + "'DISCARD'", "'DOCUMENT'", "'DOMAIN'", "'DOUBLE'", "'DROP'", "'EACH'", + "'ENABLE'", "'ENCODING'", "'ENCRYPTED'", "'ENUM'", "'ESCAPE'", "'EVENT'", + "'EXCLUDE'", "'EXCLUDING'", "'EXCLUSIVE'", "'EXECUTE'", "'EXPLAIN'", + "'EXTENSION'", "'EXTERNAL'", "'FAMILY'", "'FIRST'", "'FOLLOWING'", "'FORCE'", + "'FORWARD'", "'FUNCTION'", "'FUNCTIONS'", "'GLOBAL'", "'GRANTED'", "'HANDLER'", + "'HEADER'", "'HOLD'", "'HOUR'", "'IDENTITY'", "'IF'", "'IMMEDIATE'", + "'IMMUTABLE'", "'IMPLICIT'", "'INCLUDING'", "'INCREMENT'", "'INDEX'", + "'INDEXES'", "'INHERIT'", "'INHERITS'", "'INLINE'", "'INSENSITIVE'", + "'INSERT'", "'INSTEAD'", "'INVOKER'", "'ISOLATION'", "'KEY'", "'LABEL'", + "'LANGUAGE'", "'LARGE'", "'LAST'", "'LEAKPROOF'", "'LEVEL'", "'LISTEN'", + "'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", "'MAPPING'", "'MATCH'", + "'MATCHED'", "'MATERIALIZED'", "'MAXVALUE'", "'MERGE'", "'MINUTE'", "'MINVALUE'", + "'MODE'", "'MONTH'", "'MOVE'", "'NAME'", "'NAMES'", "'NEXT'", "'NO'", + "'NOTHING'", "'NOTIFY'", "'NOWAIT'", "'NULLS'", "'OBJECT'", "'OF'", "'OFF'", + "'OIDS'", "'OPERATOR'", "'OPTION'", "'OPTIONS'", "'OWNED'", "'OWNER'", + "'PARSER'", "'PARTIAL'", "'PARTITION'", "'PASSING'", "'PASSWORD'", "'PLANS'", + "'PRECEDING'", "'PREPARE'", "'PREPARED'", "'PRESERVE'", "'PRIOR'", "'PRIVILEGES'", + "'PROCEDURAL'", "'PROCEDURE'", "'PROGRAM'", "'QUOTE'", "'RANGE'", "'READ'", + "'REASSIGN'", "'RECHECK'", "'RECURSIVE'", "'REF'", "'REFRESH'", "'REINDEX'", + "'RELATIVE'", "'RELEASE'", "'RENAME'", "'REPEATABLE'", "'REPLACE'", "'REPLICA'", + "'RESET'", "'RESTART'", "'RESTRICT'", "'RETURNS'", "'REVOKE'", "'ROLE'", + "'ROLLBACK'", "'ROWS'", "'RULE'", "'SAVEPOINT'", "'SCHEMA'", "'SCROLL'", + "'SEARCH'", "'SECOND'", "'SECURITY'", "'SEQUENCE'", "'SEQUENCES'", "'SERIALIZABLE'", + "'SERVER'", "'SESSION'", "'SET'", "'SHARE'", "'SHOW'", "'SIMPLE'", "'SNAPSHOT'", + "'STABLE'", "'STANDALONE'", "'START'", "'STATEMENT'", "'STATISTICS'", + "'STDIN'", "'STDOUT'", "'STORAGE'", "'STRICT'", "'STRIP'", "'SYSID'", + "'SYSTEM'", "'TABLES'", "'TABLESPACE'", "'TEMP'", "'TEMPLATE'", "'TEMPORARY'", + "'TEXT'", "'TRANSACTION'", "'TRIGGER'", "'TRUNCATE'", "'TRUSTED'", "'TYPE'", + "'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", "'UNENCRYPTED'", "'UNKNOWN'", + "'UNLISTEN'", "'UNLOGGED'", "'UNTIL'", "'UPDATE'", "'VACUUM'", "'VALID'", + "'VALIDATE'", "'VALIDATOR'", "'VARYING'", "'VERSION'", "'VIEW'", "'VOLATILE'", + "'WHITESPACE'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'WRITE'", "'XML'", + "'YEAR'", "'YES'", "'ZONE'", "'BETWEEN'", "'BIGINT'", "'BIT'", "'BOOLEAN'", + "'CHAR'", "'CHARACTER'", "'COALESCE'", "'DEC'", "'DECIMAL'", "'EXISTS'", + "'EXTRACT'", "'FLOAT'", "'GREATEST'", "'INOUT'", "'INT'", "'INTEGER'", + "'INTERVAL'", "'LEAST'", "'NATIONAL'", "'NCHAR'", "'NONE'", "'NULLIF'", + "'NUMERIC'", "'OVERLAY'", "'POSITION'", "'PRECISION'", "'REAL'", "'ROW'", + "'SETOF'", "'SMALLINT'", "'SUBSTRING'", "'TIME'", "'TIMESTAMP'", "'TREAT'", + "'TRIM'", "'VALUES'", "'VARCHAR'", "'XMLATTRIBUTES'", "'XMLCOMMENT'", + "'XMLAGG'", "'XML_IS_WELL_FORMED'", "'XML_IS_WELL_FORMED_DOCUMENT'", + "'XML_IS_WELL_FORMED_CONTENT'", "'XPATH'", "'XPATH_EXISTS'", "'XMLCONCAT'", + "'XMLELEMENT'", "'XMLEXISTS'", "'XMLFOREST'", "'XMLPARSE'", "'XMLPI'", + "'XMLROOT'", "'XMLSERIALIZE'", "'CALL'", "'CURRENT'", "'ATTACH'", "'DETACH'", + "'EXPRESSION'", "'GENERATED'", "'LOGGED'", "'STORED'", "'INCLUDE'", "'ROUTINE'", + "'TRANSFORM'", "'IMPORT'", "'POLICY'", "'METHOD'", "'REFERENCING'", "'NEW'", + "'OLD'", "'VALUE'", "'SUBSCRIPTION'", "'PUBLICATION'", "'OUT'", "'END'", + "'ROUTINES'", "'SCHEMAS'", "'PROCEDURES'", "'INPUT'", "'SUPPORT'", "'PARALLEL'", + "'SQL'", "'DEPENDS'", "'OVERRIDING'", "'CONFLICT'", "'SKIP'", "'LOCKED'", + "'TIES'", "'ROLLUP'", "'CUBE'", "'GROUPING'", "'SETS'", "'TABLESAMPLE'", + "'ORDINALITY'", "'XMLTABLE'", "'COLUMNS'", "'XMLNAMESPACES'", "'ROWTYPE'", + "'NORMALIZED'", "'WITHIN'", "'FILTER'", "'GROUPS'", "'OTHERS'", "'NFC'", + "'NFD'", "'NFKC'", "'NFKD'", "'UESCAPE'", "'VIEWS'", "'NORMALIZE'", "'DUMP'", + "'PRINT_STRICT_PARAMS'", "'VARIABLE_CONFLICT'", "'ERROR'", "'USE_VARIABLE'", + "'USE_COLUMN'", "'ALIAS'", "'CONSTANT'", "'PERFORM'", "'GET'", "'DIAGNOSTICS'", + "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'", "'FOREACH'", "'SLICE'", + "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'", "'SQLSTATE'", "'DEBUG'", + "'LOG'", "'INFO'", "'NOTICE'", "'WARNING'", "'EXCEPTION'", "'ASSERT'", + "'LOOP'", "'OPEN'", "'TOP'", "'ABS'", "'CBRT'", "'CEIL'", "'CEILING'", + "'DEGREES'", "'DIV'", "'EXP'", "'FACTORIAL'", "'FLOOR'", "'GCD'", "'LCM'", + "'LN'", "'LOG10'", "'MIN_SCALE'", "'MOD'", "'PI'", "'POWER'", "'RADIANS'", + "'ROUND'", "'SCALE'", "'SIGN'", "'SQRT'", "'TRIM_SCALE'", "'TRUNC'", + "'WIDTH_BUCKET'", "'RANDOM'", "'SETSEED'", "'ACOS'", "'ACOSD'", "'ASIN'", + "'ASIND'", "'ATAN'", "'ATAND'", "'ATAN2'", "'ATAN2D'", "'COS'", "'COSD'", + "'COT'", "'COTD'", "'SIN'", "'SIND'", "'TAN'", "'TAND'", "'SINH'", "'COSH'", + "'TANH'", "'ASINH'", "'ACOSH'", "'ATANH'", "'BIT_LENGTH'", "'CHAR_LENGTH'", + "'CHARACTER_LENGTH'", "'LOWER'", "'OCTET_LENGTH'", "'UPPER'", "'ASCII'", + "'BTRIM'", "'CHR'", "'CONCAT'", "'CONCAT_WS'", "'FORMAT'", "'INITCAP'", + "'LENGTH'", "'LPAD'", "'LTRIM'", "'MD5'", "'PARSE_IDENT'", "'PG_CLIENT_ENCODING'", + "'QUOTE_IDENT'", "'QUOTE_LITERAL'", "'QUOTE_NULLABLE'", "'REGEXP_COUNT'", + "'REGEXP_INSTR'", "'REGEXP_LIKE'", "'REGEXP_MATCH'", "'REGEXP_MATCHES'", + "'REGEXP_REPLACE'", "'REGEXP_SPLIT_TO_ARRAY'", "'REGEXP_SPLIT_TO_TABLE'", + "'REGEXP_SUBSTR'", "'REPEAT'", "'RPAD'", "'RTRIM'", "'SPLIT_PART'", "'STARTS_WITH'", + "'STRING_TO_ARRAY'", "'STRING_TO_TABLE'", "'STRPOS'", "'SUBSTR'", "'TO_ASCII'", + "'TO_HEX'", "'TRANSLATE'", "'UNISTR'", "'AGE'", "'CLOCK_TIMESTAMP'", + "'DATE_BIN'", "'DATE_PART'", "'DATE_TRUNC'", "'ISFINITE'", "'JUSTIFY_DAYS'", + "'JUSTIFY_HOURS'", "'JUSTIFY_INTERVAL'", "'MAKE_DATE'", "'MAKE_INTERVAL'", + "'MAKE_TIME'", "'MAKE_TIMESTAMP'", "'MAKE_TIMESTAMPTZ'", "'NOW'", "'STATEMENT_TIMESTAMP'", + "'TIMEOFDAY'", "'TRANSACTION_TIMESTAMP'", "'TO_TIMESTAMP'", "'TO_CHAR'", + "'TO_DATE'", "'TO_NUMBER'", null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, "','", "':'", "'::'", "'$'", "'$$'", - "'*'", "'('", "')'", "'['", "']'", null, null, null, null, null, "'.'", - null, null, null, null, null, "'&'", "'&&'", "'&<'", "'@@'", "'@>'", - "'@'", "'!'", "'!!'", "'!='", "'^'", "'='", "'=>'", "'>'", "'>='", "'>>'", - "'#'", "'#='", "'#>'", "'#>>'", "'##'", "'->'", "'->>'", "'-|-'", "'<'", - "'<='", "'<@'", "'<^'", "'<>'", "'<->'", "'<<'", "'<<='", "''", "'-'", - "'%'", "'|'", "'||'", "'||/'", "'|/'", "'+'", "'?'", "'?&'", "'?#'", - "'?-'", "'?|'", "'/'", "'~'", "'~='", "'~>=~'", "'~>~'", "'~<=~'", "'~<~'", - "'~*'", "'~~'", "';'" + null, "'\\\\'", null, null, null, null, null, null, null, "'''" }; } private static final String[] _LITERAL_NAMES = makeLiteralNames(); private static String[] makeSymbolicNames() { return new String[] { - null, "WHITESPACE", "BLOCK_COMMENT", "LINE_COMMENT", "A_", "ABORT", "ABS", - "ABSOLUTE", "ACCESS", "ACTION", "ADA", "ADD", "ADMIN", "AFTER", "AGGREGATE", - "ALIAS", "ALL", "ALLOCATE", "ALSO", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE", - "AND", "ANY", "ARE", "ARRAY", "AS", "ASC", "ASENSITIVE", "ASSERTION", - "ASSIGNMENT", "ASYMMETRIC", "AT", "ATOMIC", "ATTRIBUTE", "ATTRIBUTES", - "AUTHORIZATION", "AVG", "BACKWARD", "BEFORE", "BEGIN", "BERNOULLI", "BETWEEN", - "BIGINT", "BINARY", "BIT", "BIT_LENGTH", "BITVAR", "BLOB", "BOOLEAN", - "BOTH", "BREADTH", "BUFFERS", "BY", "C_", "CACHE", "CALL", "CALLED", - "CARDINALITY", "CASCADE", "CASCADED", "CASE", "CAST", "CATALOG", "CATALOG_NAME", - "CEIL", "CEILING", "CHAIN", "CHAR", "CHAR_LENGTH", "CHARACTER", "CHARACTER_LENGTH", - "CHARACTER_SET_CATALOG", "CHARACTER_SET_NAME", "CHARACTER_SET_SCHEMA", - "CHARACTERISTICS", "CHARACTERS", "CHECK", "CHECKED", "CHECKPOINT", "CLASS", - "CLASS_ORIGIN", "CLOB", "CLOSE", "CLUSTER", "COALESCE", "COBOL", "COLLATE", - "COLLATION", "COLLATION_CATALOG", "COLLATION_NAME", "COLLATION_SCHEMA", - "COLLECT", "COLUMN", "COLUMN_NAME", "COMMAND_FUNCTION", "COMMAND_FUNCTION_CODE", - "COMMENT", "COMMIT", "COMMITTED", "COMPLETION", "CONDITION", "CONDITION_NUMBER", - "CONFIGURATION", "CONFLICT", "CONNECT", "CONNECTION", "CONNECTION_NAME", - "CONSTRAINT", "CONSTRAINT_CATALOG", "CONSTRAINT_NAME", "CONSTRAINT_SCHEMA", - "CONSTRAINTS", "CONSTRUCTOR", "CONTAINS", "CONTINUE", "CONVERSION", "CONVERT", - "COPY", "CORR", "CORRESPONDING", "COSTS", "COUNT", "COVAR_POP", "COVAR_SAMP", - "CREATE", "CREATEDB", "CREATEUSER", "CROSS", "CSV", "CUBE", "CUME_DIST", - "CURRENT", "CURRENT_DATE", "CURRENT_DEFAULT_TRANSFORM_GROUP", "CURRENT_PATH", - "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_TRANSFORM_GROUP_FOR_TYPE", - "CURRENT_USER", "CURSOR", "CURSOR_NAME", "CYCLE", "DATA", "DATABASE", - "DATE", "DATETIME_INTERVAL_CODE", "DATETIME_INTERVAL_PRECISION", "DAY", - "DEALLOCATE", "DEC", "DECIMAL", "DECLARE", "DEFAULT", "DEFAULTS", "DEFERABLE", - "DEFERRABLE", "DEFERRED", "DEFINED", "DEFINER", "DEGREE", "DELETE", "DELIMITER", - "DELIMITERS", "DENSE_RANK", "DEPENDS", "DEPTH", "DEREF", "DERIVED", "DESC", - "DESCRIBE", "DESCRIPTOR", "DESTROY", "DESTRUCTOR", "DETERMINISTIC", "DIAGNOSTICS", - "DICTIONARY", "DISABLE", "DISABLE_PAGE_SKIPPING", "DISCARD", "DISCONNECT", - "DISPATCH", "DISTINCT", "DO", "DOMAIN", "DOUBLE", "DROP", "DYNAMIC", - "DYNAMIC_FUNCTION", "DYNAMIC_FUNCTION_CODE", "EACH", "ELEMENT", "ELSE", - "ENABLE", "ENCODING", "ENCRYPTED", "END", "END_EXEC", "EQUALS", "ESCAPE", - "EVERY", "EXCEPT", "EXCEPTION", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", - "EXEC", "EXECUTE", "EXISTING", "EXISTS", "EXP", "EXPLAIN", "EXTENDED", - "EXTENSION", "EXTERNAL", "EXTRACT", "FALSE", "FETCH", "FIELDS", "FILTER", - "FINAL", "FIRST", "FLOAT", "FLOOR", "FOLLOWING", "FOR", "FORCE", "FOREIGN", - "FORMAT", "FORTRAN", "FORWARD", "FOUND", "FREE", "FREEZE", "FROM", "FULL", - "FUNCTION", "FUSION", "G_", "GENERAL", "GENERATED", "GET", "GLOBAL", - "GO", "GOTO", "GRANT", "GRANTED", "GREATEST", "GROUP", "GROUPING", "HANDLER", - "HAVING", "HIERARCHY", "HOLD", "HOST", "HOUR", "IDENTITY", "IGNORE", - "ILIKE", "IMMEDIATE", "IMMUTABLE", "IMPLEMENTATION", "IMPLICIT", "IN", - "INCLUDING", "INCREMENT", "INDEX", "INDICATOR", "INFIX", "INHERITS", - "INITIALIZE", "INITIALLY", "INNER", "INOUT", "INPUT", "INSENSITIVE", - "INSERT", "INSTANCE", "INSTANTIABLE", "INSTEAD", "INT", "INTEGER", "INTERSECT", - "INTERSECTION", "INTERVAL", "INTO", "INVOKER", "IS", "ISOLATION", "ITERATE", - "JOIN", "K_", "KEY", "KEY_MEMBER", "KEY_TYPE", "LABEL", "LANCOMPILER", - "LANGUAGE", "LARGE", "LAST", "LATERAL", "LEADING", "LEAST", "LEFT", "LENGTH", - "LESS", "LEVEL", "LIKE", "LIMIT", "LISTEN", "LN", "LOAD", "LOCAL", "LOCALTIME", - "LOCALTIMESTAMP", "LOCATION", "LOCATOR", "LOCK", "LOCKED", "LOWER", "M_", - "MAIN", "MAP", "MAPPING", "MATCH", "MATCH_SIMPLE", "MATCHED", "MAX", - "MAXVALUE", "MEMBER", "MERGE", "MESSAGE_LENGTH", "MESSAGE_OCTET_LENGTH", - "MESSAGE_TEXT", "METHOD", "MIN", "MINUTE", "MINVALUE", "MOD", "MODE", - "MODIFIES", "MODIFY", "MODULE", "MONTH", "MORE_", "MOVE", "MULTISET", - "MUMPS", "NAME", "NAMES", "NATIONAL", "NATURAL", "NCHAR", "NCLOB", "NESTING", - "NEW", "NEXT", "NO", "NOCREATEDB", "NOCREATEUSER", "NONE", "NORMALIZE", - "NORMALIZED", "NOT", "NOTHING", "NOTIFY", "NOTNULL", "NOWAIT", "NULL", - "NULLABLE", "NULLIF", "NULLS", "NUMBER", "NUMERIC", "OBJECT", "OCTET_LENGTH", - "OCTETS", "OF", "OFF", "OFFSET", "OIDS", "OLD", "ON", "ONLY", "OPEN", - "OPERATION", "OPERATOR", "OPTION", "OPTIONS", "OR", "ORDER", "ORDERING", - "ORDINALITY", "OTHERS", "OUT", "OUTER", "OUTPUT", "OVER", "OVERLAPS", - "OVERLAY", "OVERRIDING", "OWNER", "PAD", "PARAMETER", "PARAMETER_MODE", - "PARAMETER_NAME", "PARAMETER_ORDINAL_POSITION", "PARAMETER_SPECIFIC_CATALOG", - "PARAMETER_SPECIFIC_NAME", "PARAMETER_SPECIFIC_SCHEMA", "PARAMETERS", - "PARSER", "PARTIAL", "PARTITION", "PASCAL", "PASSWORD", "PATH", "PERCENT_RANK", - "PERCENTILE_CONT", "PERCENTILE_DISC", "PLACING", "PLAIN", "PLANS", "PLI", - "POSITION", "POSTFIX", "POWER", "PRECEDING", "PRECISION", "PREFIX", "PREORDER", - "PREPARE", "PREPARED", "PRESERVE", "PRIMARY", "PRIOR", "PRIVILEGES", - "PROCEDURAL", "PROCEDURE", "PUBLIC", "PUBLICATION", "QUOTE", "RANGE", - "RANK", "READ", "READS", "REAL", "REASSIGN", "RECHECK", "RECURSIVE", - "REF", "REFERENCES", "REFERENCING", "REFRESH", "REGR_AVGX", "REGR_AVGY", - "REGR_COUNT", "REGR_INTERCEPT", "REGR_R2", "REGR_SLOPE", "REGR_SXX", - "REGR_SXY", "REGR_SYY", "REINDEX", "RELATIVE", "RELEASE", "RENAME", "REPEATABLE", - "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", "RESULT", "RETURN", - "RETURNED_CARDINALITY", "RETURNED_LENGTH", "RETURNED_OCTET_LENGTH", "RETURNED_SQLSTATE", - "RETURNING", "RETURNS", "REVOKE", "RIGHT", "ROLE", "ROLLBACK", "ROLLUP", - "ROUTINE", "ROUTINE_CATALOG", "ROUTINE_NAME", "ROUTINE_SCHEMA", "ROW", - "ROW_COUNT", "ROW_NUMBER", "ROWS", "RULE", "SAVEPOINT", "SCALE", "SCHEMA", - "SCHEMA_NAME", "SCOPE", "SCOPE_CATALOG", "SCOPE_NAME", "SCOPE_SCHEMA", - "SCROLL", "SEARCH", "SECOND", "SECTION", "SECURITY", "SELECT", "SELF", - "SENSITIVE", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER_NAME", - "SESSION", "SESSION_USER", "SET", "SETOF", "SETS", "SHARE", "SHOW", "SIMILAR", - "SIMPLE", "SIZE", "SKIP_", "SMALLINT", "SNAPSHOT", "SOME", "SOURCE", - "SPACE", "SPECIFIC", "SPECIFIC_NAME", "SPECIFICTYPE", "SQL", "SQLCODE", - "SQLERROR", "SQLEXCEPTION", "SQLSTATE", "SQLWARNING", "SQRT", "STABLE", - "START", "STATE", "STATEMENT", "STATIC", "STATISTICS", "STDDEV_POP", - "STDDEV_SAMP", "STDIN", "STDOUT", "STORAGE", "STRICT", "STRUCTURE", "STYLE", - "SUBCLASS_ORIGIN", "SUBLIST", "SUBMULTISET", "SUBSCRIPTION", "SUBSTRING", - "SUM", "SYMMETRIC", "SYSID", "SYSTEM", "SYSTEM_USER", "TABLE", "TABLE_NAME", - "TABLESAMPLE", "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TERMINATE", - "THAN", "THEN", "TIES", "TIME", "TIMESTAMP", "TIMEZONE_HOUR", "TIMEZONE_MINUTE", - "TIMING", "TO", "TOAST", "TOP", "TOP_LEVEL_COUNT", "TRAILING", "TRANSACTION", - "TRANSACTION_ACTIVE", "TRANSACTIONS_COMMITTED", "TRANSACTIONS_ROLLED_BACK", - "TRANSFORM", "TRANSFORMS", "TRANSLATE", "TRANSLATION", "TREAT", "TRIGGER", - "TRIGGER_CATALOG", "TRIGGER_NAME", "TRIGGER_SCHEMA", "TRIM", "TRUE", - "TRUNCATE", "TRUSTED", "TYPE", "UESCAPE", "UNBOUNDED", "UNCOMMITTED", - "UNDER", "UNENCRYPTED", "UNION", "UNIQUE", "UNKNOWN", "UNLISTEN", "UNLOGGED", - "UNNAMED", "UNNEST", "UNTIL", "UPDATE", "UPPER", "USAGE", "USER", "USER_DEFINED_TYPE_CATALOG", - "USER_DEFINED_TYPE_CODE", "USER_DEFINED_TYPE_NAME", "USER_DEFINED_TYPE_SCHEMA", - "USING", "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VALUE", "VALUES", - "VAR_POP", "VAR_SAMP", "VARCHAR", "VARIABLE", "VARIADIC", "VARYING", - "VERBOSE", "VIEW", "VOLATILE", "WHEN", "WHENEVER", "WHERE", "WIDTH_BUCKET", - "WINDOW", "WITH", "WITHIN", "WITHOUT", "WORK", "WRITE", "YAML", "YEAR", - "YES", "ZONE", "SUPERUSER", "NOSUPERUSER", "CREATEROLE", "NOCREATEROLE", - "INHERIT", "NOINHERIT", "LOGIN", "NOLOGIN", "REPLICATION", "NOREPLICATION", - "BYPASSRLS", "NOBYPASSRLS", "SFUNC", "STYPE", "SSPACE", "FINALFUNC", - "FINALFUNC_EXTRA", "COMBINEFUNC", "SERIALFUNC", "DESERIALFUNC", "INITCOND", - "MSFUNC", "MINVFUNC", "MSTYPE", "MSSPACE", "MFINALFUNC", "MFINALFUNC_EXTRA", - "MINITCOND", "SORTOP", "PARALLEL", "HYPOTHETICAL", "SAFE", "RESTRICTED", - "UNSAFE", "BASETYPE", "IF", "LOCALE", "LC_COLLATE", "LC_CTYPE", "PROVIDER", - "VERSION", "ALLOW_CONNECTIONS", "IS_TEMPLATE", "EVENT", "WRAPPER", "SERVER", - "BTREE", "HASH_", "GIST", "SPGIST", "GIN", "BRIN", "CONCURRENTLY", "INLINE", - "MATERIALIZED", "LEFTARG", "RIGHTARG", "COMMUTATOR", "NEGATOR", "HASHES", - "MERGES", "FAMILY", "POLICY", "OWNED", "ABSTIME", "BIGSERIAL", "BIT_VARYING", - "BOOL", "BOX", "BYTEA", "CHARACTER_VARYING", "CIDR", "CIRCLE", "FLOAT4", - "FLOAT8", "INET", "INT2", "INT4", "INT8", "JSON", "JSONB", "LINE", "LSEG", - "MACADDR", "MACADDR8", "MONEY", "PG_LSN", "POINT", "POLYGON", "RELTIME", - "SERIAL", "SERIAL2", "SERIAL4", "SERIAL8", "SMALLSERIAL", "STSTEM", "TEXT", - "TIMESTAMPTZ", "TIMETZ", "TSQUERY", "TSVECTOR", "TXID_SNAPSHOT", "UUID", - "VARBIT", "XML", "COMMA", "COLON", "COLON_COLON", "DOLLAR", "DOLLAR_DOLLAR", - "STAR", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET", - "BIT_STRING", "REGEX_STRING", "NUMERIC_LITERAL", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", - "DOT", "SINGLEQ_STRING_LITERAL", "DOUBLEQ_STRING_LITERAL", "IDENTIFIER", - "DOLLAR_DEC", "IDENTIFIER_UNICODE", "AMP", "AMP_AMP", "AMP_LT", "AT_AT", - "AT_GT", "AT_SIGN", "BANG", "BANG_BANG", "BANG_EQUAL", "CARET", "EQUAL", - "EQUAL_GT", "GT", "GTE", "GT_GT", "HASH", "HASH_EQ", "HASH_GT", "HASH_GT_GT", - "HASH_HASH", "HYPHEN_GT", "HYPHEN_GT_GT", "HYPHEN_PIPE_HYPHEN", "LT", - "LTE", "LT_AT", "LT_CARET", "LT_GT", "LT_HYPHEN_GT", "LT_LT", "LT_LT_EQ", - "LT_QMARK_GT", "MINUS", "PERCENT", "PIPE", "PIPE_PIPE", "PIPE_PIPE_SLASH", - "PIPE_SLASH", "PLUS", "QMARK", "QMARK_AMP", "QMARK_HASH", "QMARK_HYPHEN", - "QMARK_PIPE", "SLASH", "TIL", "TIL_EQ", "TIL_GTE_TIL", "TIL_GT_TIL", - "TIL_LTE_TIL", "TIL_LT_TIL", "TIL_STAR", "TIL_TIL", "SEMI", "SPEL" + null, "SPEL", "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", + "CLOSE_BRACKET", "COMMA", "SEMI", "COLON", "QUESTION", "STAR", "EQUAL", + "DOT", "PLUS", "MINUS", "SLASH", "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", + "COLON_EQUALS", "LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", "DOT_DOT", + "NOT_EQUALS", "TYPECAST", "PERCENT", "PARAM", "Operator", "ALL", "ANALYSE", + "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", + "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", + "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", + "CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE", + "EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP_P", + "HAVING", "IN_P", "INITIALLY", "INTERSECT", "INTO", "LATERAL_P", "LEADING", + "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL_P", "OFFSET", "ON", + "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", "REFERENCES", "RETURNING", + "SELECT", "SESSION_USER", "SOME", "SYMMETRIC", "TABLE", "THEN", "TO", + "TRAILING", "TRUE_P", "UNION", "UNIQUE", "USER", "USING", "VARIADIC", + "WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", "BINARY", "COLLATION", + "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", "FREEZE", "FULL", "ILIKE", + "INNER_P", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL", "NOTNULL", + "OUTER_P", "OVER", "OVERLAPS", "RIGHT", "SIMILAR", "VERBOSE", "ABORT_P", + "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE", + "ALSO", "ALTER", "ALWAYS", "ASSERTION", "ASSIGNMENT", "AT", "ATTRIBUTE", + "BACKWARD", "BEFORE", "BEGIN_P", "BY", "CACHE", "CALLED", "CASCADE", + "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", "CLASS", + "CLOSE", "CLUSTER", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "CONFIGURATION", + "CONNECTION", "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P", + "COPY", "COST", "CSV", "CURSOR", "CYCLE", "DATA_P", "DATABASE", "DAY_P", + "DEALLOCATE", "DECLARE", "DEFAULTS", "DEFERRED", "DEFINER", "DELETE_P", + "DELIMITER", "DELIMITERS", "DICTIONARY", "DISABLE_P", "DISCARD", "DOCUMENT_P", + "DOMAIN_P", "DOUBLE_P", "DROP", "EACH", "ENABLE_P", "ENCODING", "ENCRYPTED", + "ENUM_P", "ESCAPE", "EVENT", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", + "EXPLAIN", "EXTENSION", "EXTERNAL", "FAMILY", "FIRST_P", "FOLLOWING", + "FORCE", "FORWARD", "FUNCTION", "FUNCTIONS", "GLOBAL", "GRANTED", "HANDLER", + "HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE", + "IMPLICIT_P", "INCLUDING", "INCREMENT", "INDEX", "INDEXES", "INHERIT", + "INHERITS", "INLINE_P", "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", + "ISOLATION", "KEY", "LABEL", "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF", + "LEVEL", "LISTEN", "LOAD", "LOCAL", "LOCATION", "LOCK_P", "MAPPING", + "MATCH", "MATCHED", "MATERIALIZED", "MAXVALUE", "MERGE", "MINUTE_P", + "MINVALUE", "MODE", "MONTH_P", "MOVE", "NAME_P", "NAMES", "NEXT", "NO", + "NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", "OBJECT_P", "OF", "OFF", "OIDS", + "OPERATOR", "OPTION", "OPTIONS", "OWNED", "OWNER", "PARSER", "PARTIAL", + "PARTITION", "PASSING", "PASSWORD", "PLANS", "PRECEDING", "PREPARE", + "PREPARED", "PRESERVE", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", + "PROGRAM", "QUOTE", "RANGE", "READ", "REASSIGN", "RECHECK", "RECURSIVE", + "REF", "REFRESH", "REINDEX", "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE", + "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE", + "ROLE", "ROLLBACK", "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", + "SEARCH", "SECOND_P", "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", + "SERVER", "SESSION", "SET", "SHARE", "SHOW", "SIMPLE", "SNAPSHOT", "STABLE", + "STANDALONE_P", "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT", + "STORAGE", "STRICT_P", "STRIP_P", "SYSID", "SYSTEM_P", "TABLES", "TABLESPACE", + "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P", "TRANSACTION", "TRIGGER", + "TRUNCATE", "TRUSTED", "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED", + "UNENCRYPTED", "UNKNOWN", "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE", + "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VARYING", "VERSION_P", "VIEW", + "VOLATILE", "WHITESPACE_P", "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML_P", + "YEAR_P", "YES_P", "ZONE", "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P", "CHAR_P", + "CHARACTER", "COALESCE", "DEC", "DECIMAL_P", "EXISTS", "EXTRACT", "FLOAT_P", + "GREATEST", "INOUT", "INT_P", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", + "NCHAR", "NONE", "NULLIF", "NUMERIC", "OVERLAY", "POSITION", "PRECISION", + "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", "TIME", "TIMESTAMP", + "TREAT", "TRIM", "VALUES", "VARCHAR", "XMLATTRIBUTES", "XMLCOMMENT", + "XMLAGG", "XML_IS_WELL_FORMED", "XML_IS_WELL_FORMED_DOCUMENT", "XML_IS_WELL_FORMED_CONTENT", + "XPATH", "XPATH_EXISTS", "XMLCONCAT", "XMLELEMENT", "XMLEXISTS", "XMLFOREST", + "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE", "CALL", "CURRENT_P", + "ATTACH", "DETACH", "EXPRESSION", "GENERATED", "LOGGED", "STORED", "INCLUDE", + "ROUTINE", "TRANSFORM", "IMPORT_P", "POLICY", "METHOD", "REFERENCING", + "NEW", "OLD", "VALUE_P", "SUBSCRIPTION", "PUBLICATION", "OUT_P", "END_P", + "ROUTINES", "SCHEMAS", "PROCEDURES", "INPUT_P", "SUPPORT", "PARALLEL", + "SQL_P", "DEPENDS", "OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", + "ROLLUP", "CUBE", "GROUPING", "SETS", "TABLESAMPLE", "ORDINALITY", "XMLTABLE", + "COLUMNS", "XMLNAMESPACES", "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", + "GROUPS", "OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", "VIEWS", + "NORMALIZE", "DUMP", "PRINT_STRICT_PARAMS", "VARIABLE_CONFLICT", "ERROR", + "USE_VARIABLE", "USE_COLUMN", "ALIAS", "CONSTANT", "PERFORM", "GET", + "DIAGNOSTICS", "STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", "SLICE", + "EXIT", "RETURN", "QUERY", "RAISE", "SQLSTATE", "DEBUG", "LOG", "INFO", + "NOTICE", "WARNING", "EXCEPTION", "ASSERT", "LOOP", "OPEN", "TOP", "ABS", + "CBRT", "CEIL", "CEILING", "DEGREES", "DIV", "EXP", "FACTORIAL", "FLOOR", + "GCD", "LCM", "LN", "LOG10", "MIN_SCALE", "MOD", "PI", "POWER", "RADIANS", + "ROUND", "SCALE", "SIGN", "SQRT", "TRIM_SCALE", "TRUNC", "WIDTH_BUCKET", + "RANDOM", "SETSEED", "ACOS", "ACOSD", "ASIN", "ASIND", "ATAN", "ATAND", + "ATAN2", "ATAN2D", "COS", "COSD", "COT", "COTD", "SIN", "SIND", "TAN", + "TAND", "SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "BIT_LENGTH", + "CHAR_LENGTH", "CHARACTER_LENGTH", "LOWER", "OCTET_LENGTH", "UPPER", + "ASCII", "BTRIM", "CHR", "CONCAT", "CONCAT_WS", "FORMAT", "INITCAP", + "LENGTH", "LPAD", "LTRIM", "MD5", "PARSE_IDENT", "PG_CLIENT_ENCODING", + "QUOTE_IDENT", "QUOTE_LITERAL", "QUOTE_NULLABLE", "REGEXP_COUNT", "REGEXP_INSTR", + "REGEXP_LIKE", "REGEXP_MATCH", "REGEXP_MATCHES", "REGEXP_REPLACE", "REGEXP_SPLIT_TO_ARRAY", + "REGEXP_SPLIT_TO_TABLE", "REGEXP_SUBSTR", "REPEAT", "RPAD", "RTRIM", + "SPLIT_PART", "STARTS_WITH", "STRING_TO_ARRAY", "STRING_TO_TABLE", "STRPOS", + "SUBSTR", "TO_ASCII", "TO_HEX", "TRANSLATE", "UNISTR", "AGE", "CLOCK_TIMESTAMP", + "DATE_BIN", "DATE_PART", "DATE_TRUNC", "ISFINITE", "JUSTIFY_DAYS", "JUSTIFY_HOURS", + "JUSTIFY_INTERVAL", "MAKE_DATE", "MAKE_INTERVAL", "MAKE_TIME", "MAKE_TIMESTAMP", + "MAKE_TIMESTAMPTZ", "NOW", "STATEMENT_TIMESTAMP", "TIMEOFDAY", "TRANSACTION_TIMESTAMP", + "TO_TIMESTAMP", "TO_CHAR", "TO_DATE", "TO_NUMBER", "Identifier", "QuotedIdentifier", + "UnterminatedQuotedIdentifier", "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier", + "UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", "InvalidUnicodeQuotedIdentifier", + "InvalidUnterminatedUnicodeQuotedIdentifier", "StringConstant", "UnterminatedStringConstant", + "UnicodeEscapeStringConstant", "UnterminatedUnicodeEscapeStringConstant", + "BeginDollarStringConstant", "BinaryStringConstant", "UnterminatedBinaryStringConstant", + "InvalidBinaryStringConstant", "InvalidUnterminatedBinaryStringConstant", + "HexadecimalStringConstant", "UnterminatedHexadecimalStringConstant", + "InvalidHexadecimalStringConstant", "InvalidUnterminatedHexadecimalStringConstant", + "Integral", "NumericFail", "Numeric", "PLSQLIDENTIFIER", "Whitespace", + "Newline", "LineComment", "BlockComment", "UnterminatedBlockComment", + "MetaCommand", "EndMetaCommand", "ErrorCharacter", "EscapeStringConstant", + "UnterminatedEscapeStringConstant", "InvalidEscapeStringConstant", "InvalidUnterminatedEscapeStringConstant", + "DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued" }; } private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); @@ -562,6 +537,10 @@ public class PostgreSqlLexer extends Lexer { } + /* This field stores the tags which are used to detect the end of a dollar-quoted string literal. + */ + + public PostgreSqlLexer(CharStream input) { super(input); _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); @@ -585,8 +564,123 @@ public class PostgreSqlLexer extends Lexer { @Override public ATN getATN() { return _ATN; } + @Override + public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + case 31: + Operator_action((RuleContext)_localctx, actionIndex); + break; + case 660: + BeginDollarStringConstant_action((RuleContext)_localctx, actionIndex); + break; + case 671: + NumericFail_action((RuleContext)_localctx, actionIndex); + break; + case 679: + UnterminatedBlockComment_action((RuleContext)_localctx, actionIndex); + break; + case 695: + EndDollarStringConstant_action((RuleContext)_localctx, actionIndex); + break; + } + } + private void Operator_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 0: + + HandleLessLessGreaterGreater(); + + break; + } + } + private void BeginDollarStringConstant_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 1: + pushTag(); + break; + } + } + private void NumericFail_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 2: + HandleNumericFail(); + break; + } + } + private void UnterminatedBlockComment_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 3: + + UnterminatedBlockCommentDebugAssert(); + + break; + } + } + private void EndDollarStringConstant_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 4: + popTag(); + break; + } + } + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 31: + return Operator_sempred((RuleContext)_localctx, predIndex); + case 32: + return OperatorEndingWithPlusMinus_sempred((RuleContext)_localctx, predIndex); + case 644: + return IdentifierStartChar_sempred((RuleContext)_localctx, predIndex); + case 695: + return EndDollarStringConstant_sempred((RuleContext)_localctx, predIndex); + } + return true; + } + private boolean Operator_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return checkLA('-'); + case 1: + return checkLA('*'); + case 2: + return checkLA('*'); + } + return true; + } + private boolean OperatorEndingWithPlusMinus_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 3: + return checkLA('-'); + case 4: + return checkLA('*'); + case 5: + return checkLA('-'); + } + return true; + } + private boolean IdentifierStartChar_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 6: + return charIsLetter(); + case 7: + return + CheckIfUtf32Letter() + ; + } + return true; + } + private boolean EndDollarStringConstant_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 8: + return isTag(); + } + return true; + } + private static final String _serializedATNSegment0 = - "\u0004\u0000\u0345\u2206\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002"+ + "\u0004\u0000\u02a7\u1aa2\u0006\uffff\uffff\u0006\uffff\uffff\u0006\uffff"+ + "\uffff\u0006\uffff\uffff\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002"+ "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002"+ "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002"+ "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002"+ @@ -805,5404 +899,4333 @@ public class PostgreSqlLexer extends Lexer { "\u0002\u02ae\u0007\u02ae\u0002\u02af\u0007\u02af\u0002\u02b0\u0007\u02b0"+ "\u0002\u02b1\u0007\u02b1\u0002\u02b2\u0007\u02b2\u0002\u02b3\u0007\u02b3"+ "\u0002\u02b4\u0007\u02b4\u0002\u02b5\u0007\u02b5\u0002\u02b6\u0007\u02b6"+ - "\u0002\u02b7\u0007\u02b7\u0002\u02b8\u0007\u02b8\u0002\u02b9\u0007\u02b9"+ - "\u0002\u02ba\u0007\u02ba\u0002\u02bb\u0007\u02bb\u0002\u02bc\u0007\u02bc"+ - "\u0002\u02bd\u0007\u02bd\u0002\u02be\u0007\u02be\u0002\u02bf\u0007\u02bf"+ - "\u0002\u02c0\u0007\u02c0\u0002\u02c1\u0007\u02c1\u0002\u02c2\u0007\u02c2"+ - "\u0002\u02c3\u0007\u02c3\u0002\u02c4\u0007\u02c4\u0002\u02c5\u0007\u02c5"+ - "\u0002\u02c6\u0007\u02c6\u0002\u02c7\u0007\u02c7\u0002\u02c8\u0007\u02c8"+ - "\u0002\u02c9\u0007\u02c9\u0002\u02ca\u0007\u02ca\u0002\u02cb\u0007\u02cb"+ - "\u0002\u02cc\u0007\u02cc\u0002\u02cd\u0007\u02cd\u0002\u02ce\u0007\u02ce"+ - "\u0002\u02cf\u0007\u02cf\u0002\u02d0\u0007\u02d0\u0002\u02d1\u0007\u02d1"+ - "\u0002\u02d2\u0007\u02d2\u0002\u02d3\u0007\u02d3\u0002\u02d4\u0007\u02d4"+ - "\u0002\u02d5\u0007\u02d5\u0002\u02d6\u0007\u02d6\u0002\u02d7\u0007\u02d7"+ - "\u0002\u02d8\u0007\u02d8\u0002\u02d9\u0007\u02d9\u0002\u02da\u0007\u02da"+ - "\u0002\u02db\u0007\u02db\u0002\u02dc\u0007\u02dc\u0002\u02dd\u0007\u02dd"+ - "\u0002\u02de\u0007\u02de\u0002\u02df\u0007\u02df\u0002\u02e0\u0007\u02e0"+ - "\u0002\u02e1\u0007\u02e1\u0002\u02e2\u0007\u02e2\u0002\u02e3\u0007\u02e3"+ - "\u0002\u02e4\u0007\u02e4\u0002\u02e5\u0007\u02e5\u0002\u02e6\u0007\u02e6"+ - "\u0002\u02e7\u0007\u02e7\u0002\u02e8\u0007\u02e8\u0002\u02e9\u0007\u02e9"+ - "\u0002\u02ea\u0007\u02ea\u0002\u02eb\u0007\u02eb\u0002\u02ec\u0007\u02ec"+ - "\u0002\u02ed\u0007\u02ed\u0002\u02ee\u0007\u02ee\u0002\u02ef\u0007\u02ef"+ - "\u0002\u02f0\u0007\u02f0\u0002\u02f1\u0007\u02f1\u0002\u02f2\u0007\u02f2"+ - "\u0002\u02f3\u0007\u02f3\u0002\u02f4\u0007\u02f4\u0002\u02f5\u0007\u02f5"+ - "\u0002\u02f6\u0007\u02f6\u0002\u02f7\u0007\u02f7\u0002\u02f8\u0007\u02f8"+ - "\u0002\u02f9\u0007\u02f9\u0002\u02fa\u0007\u02fa\u0002\u02fb\u0007\u02fb"+ - "\u0002\u02fc\u0007\u02fc\u0002\u02fd\u0007\u02fd\u0002\u02fe\u0007\u02fe"+ - "\u0002\u02ff\u0007\u02ff\u0002\u0300\u0007\u0300\u0002\u0301\u0007\u0301"+ - "\u0002\u0302\u0007\u0302\u0002\u0303\u0007\u0303\u0002\u0304\u0007\u0304"+ - "\u0002\u0305\u0007\u0305\u0002\u0306\u0007\u0306\u0002\u0307\u0007\u0307"+ - "\u0002\u0308\u0007\u0308\u0002\u0309\u0007\u0309\u0002\u030a\u0007\u030a"+ - "\u0002\u030b\u0007\u030b\u0002\u030c\u0007\u030c\u0002\u030d\u0007\u030d"+ - "\u0002\u030e\u0007\u030e\u0002\u030f\u0007\u030f\u0002\u0310\u0007\u0310"+ - "\u0002\u0311\u0007\u0311\u0002\u0312\u0007\u0312\u0002\u0313\u0007\u0313"+ - "\u0002\u0314\u0007\u0314\u0002\u0315\u0007\u0315\u0002\u0316\u0007\u0316"+ - "\u0002\u0317\u0007\u0317\u0002\u0318\u0007\u0318\u0002\u0319\u0007\u0319"+ - "\u0002\u031a\u0007\u031a\u0002\u031b\u0007\u031b\u0002\u031c\u0007\u031c"+ - "\u0002\u031d\u0007\u031d\u0002\u031e\u0007\u031e\u0002\u031f\u0007\u031f"+ - "\u0002\u0320\u0007\u0320\u0002\u0321\u0007\u0321\u0002\u0322\u0007\u0322"+ - "\u0002\u0323\u0007\u0323\u0002\u0324\u0007\u0324\u0002\u0325\u0007\u0325"+ - "\u0002\u0326\u0007\u0326\u0002\u0327\u0007\u0327\u0002\u0328\u0007\u0328"+ - "\u0002\u0329\u0007\u0329\u0002\u032a\u0007\u032a\u0002\u032b\u0007\u032b"+ - "\u0002\u032c\u0007\u032c\u0002\u032d\u0007\u032d\u0002\u032e\u0007\u032e"+ - "\u0002\u032f\u0007\u032f\u0002\u0330\u0007\u0330\u0002\u0331\u0007\u0331"+ - "\u0002\u0332\u0007\u0332\u0002\u0333\u0007\u0333\u0002\u0334\u0007\u0334"+ - "\u0002\u0335\u0007\u0335\u0002\u0336\u0007\u0336\u0002\u0337\u0007\u0337"+ - "\u0002\u0338\u0007\u0338\u0002\u0339\u0007\u0339\u0002\u033a\u0007\u033a"+ - "\u0002\u033b\u0007\u033b\u0002\u033c\u0007\u033c\u0002\u033d\u0007\u033d"+ - "\u0002\u033e\u0007\u033e\u0002\u033f\u0007\u033f\u0002\u0340\u0007\u0340"+ - "\u0002\u0341\u0007\u0341\u0002\u0342\u0007\u0342\u0002\u0343\u0007\u0343"+ - "\u0002\u0344\u0007\u0344\u0002\u0345\u0007\u0345\u0002\u0346\u0007\u0346"+ - "\u0002\u0347\u0007\u0347\u0002\u0348\u0007\u0348\u0002\u0349\u0007\u0349"+ - "\u0002\u034a\u0007\u034a\u0002\u034b\u0007\u034b\u0002\u034c\u0007\u034c"+ - "\u0002\u034d\u0007\u034d\u0002\u034e\u0007\u034e\u0002\u034f\u0007\u034f"+ - "\u0002\u0350\u0007\u0350\u0002\u0351\u0007\u0351\u0002\u0352\u0007\u0352"+ - "\u0002\u0353\u0007\u0353\u0002\u0354\u0007\u0354\u0002\u0355\u0007\u0355"+ - "\u0002\u0356\u0007\u0356\u0002\u0357\u0007\u0357\u0002\u0358\u0007\u0358"+ - "\u0002\u0359\u0007\u0359\u0002\u035a\u0007\u035a\u0002\u035b\u0007\u035b"+ - "\u0002\u035c\u0007\u035c\u0002\u035d\u0007\u035d\u0002\u035e\u0007\u035e"+ - "\u0002\u035f\u0007\u035f\u0002\u0360\u0007\u0360\u0002\u0361\u0007\u0361"+ - "\u0002\u0362\u0007\u0362\u0002\u0363\u0007\u0363\u0002\u0364\u0007\u0364"+ - "\u0001\u0000\u0004\u0000\u06cd\b\u0000\u000b\u0000\f\u0000\u06ce\u0001"+ - "\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0005"+ - "\u0001\u06d7\b\u0001\n\u0001\f\u0001\u06da\t\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002"+ - "\u0001\u0002\u0005\u0002\u06e5\b\u0002\n\u0002\f\u0002\u06e8\t\u0002\u0001"+ - "\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001"+ - "\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001"+ - "\u0007\u0001\u0007\u0001\b\u0001\b\u0001\t\u0001\t\u0001\n\u0001\n\u0001"+ - "\u000b\u0001\u000b\u0001\f\u0001\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e"+ - "\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011"+ - "\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014"+ - "\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017"+ - "\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a"+ - "\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d"+ - "\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f"+ - "\u0001\u001f\u0001\u001f\u0005\u001f\u072c\b\u001f\n\u001f\f\u001f\u072f"+ - "\t\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+ - " \u0005 \u0739\b \n \f \u073c\t \u0001 \u0001 \u0001!\u0001!\u0001!\u0001"+ - "!\u0001!\u0001!\u0005!\u0746\b!\n!\f!\u0749\t!\u0001!\u0001!\u0001\"\u0001"+ - "\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001$\u0001"+ - "$\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001"+ - "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0001)\u0001)\u0001"+ - ")\u0001)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001+\u0001+\u0001"+ - "+\u0001+\u0001+\u0001+\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ - ",\u0001,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001"+ - ".\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ - "/\u0001/\u0001/\u00010\u00010\u00010\u00010\u00010\u00011\u00011\u0001"+ - "1\u00011\u00011\u00011\u00012\u00012\u00012\u00012\u00012\u00012\u0001"+ - "2\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u00014\u0001"+ - "4\u00014\u00014\u00014\u00014\u00014\u00014\u00015\u00015\u00015\u0001"+ - "5\u00016\u00016\u00016\u00016\u00017\u00017\u00017\u00017\u00018\u0001"+ - "8\u00018\u00018\u00018\u00018\u00019\u00019\u00019\u0001:\u0001:\u0001"+ - ":\u0001:\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001"+ - ";\u0001;\u0001;\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001"+ - "<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001"+ + "\u0002\u02b7\u0007\u02b7\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+ + "\u0001\u0000\u0001\u0000\u0001\u0001\u0005\u0001\u057d\b\u0001\n\u0001"+ + "\f\u0001\u0580\t\u0001\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003"+ + "\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006"+ + "\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\t\u0001\t\u0001\n\u0001"+ + "\n\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\r\u0001\r\u0001\u000e"+ + "\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0011"+ + "\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0014"+ + "\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0016"+ + "\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0018"+ + "\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a"+ + "\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c"+ + "\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e"+ + "\u0004\u001e\u05c5\b\u001e\u000b\u001e\f\u001e\u05c6\u0001\u001f\u0001"+ + "\u001f\u0001\u001f\u0001\u001f\u0004\u001f\u05cd\b\u001f\u000b\u001f\f"+ + "\u001f\u05ce\u0001\u001f\u0001\u001f\u0001\u001f\u0003\u001f\u05d4\b\u001f"+ + "\u0001\u001f\u0001\u001f\u0004\u001f\u05d8\b\u001f\u000b\u001f\f\u001f"+ + "\u05d9\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ + "\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ + "\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0003\u001f\u05ec"+ + "\b\u001f\u0003\u001f\u05ee\b\u001f\u0001\u001f\u0001\u001f\u0001 \u0001"+ + " \u0001 \u0001 \u0001 \u0005 \u05f7\b \n \f \u05fa\t \u0001 \u0001 \u0003"+ + " \u05fe\b \u0001 \u0001 \u0001 \u0004 \u0603\b \u000b \f \u0604\u0001"+ + " \u0001 \u0001!\u0001!\u0001\"\u0001\"\u0001#\u0001#\u0001$\u0001$\u0001"+ + "$\u0001$\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001"+ + "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0001"+ + "\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001)\u0001"+ + ")\u0001)\u0001*\u0001*\u0001*\u0001+\u0001+\u0001+\u0001+\u0001,\u0001"+ + ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ + "-\u0001-\u0001-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001.\u0001.\u0001"+ + "/\u0001/\u0001/\u0001/\u0001/\u00010\u00010\u00010\u00010\u00010\u0001"+ + "0\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u00012\u0001"+ + "2\u00012\u00012\u00012\u00012\u00012\u00013\u00013\u00013\u00013\u0001"+ + "3\u00013\u00013\u00013\u00013\u00013\u00013\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00015\u00015\u00015\u00015\u00015\u00015\u0001"+ + "5\u00015\u00015\u00015\u00015\u00015\u00015\u00015\u00015\u00015\u0001"+ + "6\u00016\u00016\u00016\u00016\u00016\u00016\u00016\u00016\u00016\u0001"+ + "6\u00016\u00016\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+ + "7\u00017\u00017\u00017\u00017\u00017\u00018\u00018\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00019\u0001:\u0001:\u0001:\u0001"+ + ":\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001"+ + ";\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001<\u0001<\u0001"+ + "<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001=\u0001"+ "=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001>\u0001>\u0001"+ - ">\u0001>\u0001>\u0001>\u0001>\u0001?\u0001?\u0001?\u0001@\u0001@\u0001"+ - "@\u0001@\u0001@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001A\u0001A\u0001"+ - "A\u0001A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001B\u0001B\u0001"+ - "B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0001C\u0001"+ - "C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+ + ">\u0001>\u0001>\u0001?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001@\u0001"+ + "@\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001"+ + "B\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+ "D\u0001D\u0001D\u0001D\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001"+ - "E\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+ - "G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001H\u0001H\u0001H\u0001H\u0001"+ - "H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001"+ - "I\u0001I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ - "J\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001"+ - "L\u0001L\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+ - "M\u0001M\u0001M\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001"+ - "O\u0001O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001"+ - "P\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001"+ - "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001S\u0001"+ - "S\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001U\u0001U\u0001V\u0001"+ - "V\u0001V\u0001V\u0001V\u0001V\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+ - "X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001"+ - "Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Z\u0001"+ - "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001[\u0001[\u0001[\u0001"+ - "[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ - "\\\u0001]\u0001]\u0001]\u0001]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001"+ - "^\u0001^\u0001^\u0001^\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001"+ - "_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001"+ - "`\u0001`\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001"+ - "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001c\u0001c\u0001c\u0001c\u0001"+ - "c\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001"+ - "d\u0001d\u0001d\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001"+ - "e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001"+ - "f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001"+ - "g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001"+ - "g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001"+ - "g\u0001g\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001"+ - "h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001"+ - "h\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+ - "i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+ - "i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ - "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001k\u0001k\u0001"+ - "k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001l\u0001"+ - "l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m\u0001m\u0001m\u0001"+ - "m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001"+ - "n\u0001n\u0001n\u0001n\u0001o\u0001o\u0001o\u0001o\u0001o\u0001o\u0001"+ - "p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+ - "p\u0001p\u0001p\u0001q\u0001q\u0001q\u0001q\u0001q\u0001r\u0001r\u0001"+ - "r\u0001r\u0001r\u0001r\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001"+ - "s\u0001s\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001"+ - "t\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001"+ - "v\u0001v\u0001v\u0001v\u0001v\u0001w\u0001w\u0001w\u0001w\u0001w\u0001"+ - "w\u0001w\u0001w\u0001w\u0001w\u0001x\u0001x\u0001x\u0001x\u0001x\u0001"+ - "x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001"+ - "x\u0001x\u0001x\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001"+ - "y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001z\u0001z\u0001"+ - "z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001"+ - "z\u0001z\u0001z\u0001z\u0001z\u0001{\u0001{\u0001{\u0001{\u0001{\u0001"+ - "{\u0001{\u0001{\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001"+ - "}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001"+ - "}\u0001}\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001"+ - "~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001\u007f"+ - "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ - "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ - "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ - "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u0080\u0001\u0080\u0001\u0080"+ - "\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0081"+ - "\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081"+ - "\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082"+ - "\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0083\u0001\u0083"+ - "\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083"+ - "\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0084\u0001\u0084\u0001\u0084"+ - "\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084"+ - "\u0001\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085"+ - "\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085"+ - "\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085"+ - "\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086"+ - "\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086"+ - "\u0001\u0086\u0001\u0086\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087"+ - "\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0088"+ - "\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088"+ - "\u0001\u0088\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089"+ - "\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089"+ - "\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a"+ - "\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a"+ - "\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008b\u0001\u008b"+ - "\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b"+ - "\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c\u0001\u008c"+ - "\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c"+ - "\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c"+ - "\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008d\u0001\u008d"+ - "\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d"+ - "\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d"+ - "\u0001\u008d\u0001\u008d\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e"+ - "\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e"+ - "\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e"+ - "\u0001\u008e\u0001\u008e\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f"+ - "\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f"+ - "\u0001\u008f\u0001\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090"+ - "\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090"+ - "\u0001\u0090\u0001\u0090\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091"+ - "\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0092"+ - "\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092"+ - "\u0001\u0092\u0001\u0092\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093"+ - "\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093"+ - "\u0001\u0093\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094"+ - "\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0095\u0001\u0095\u0001\u0095"+ - "\u0001\u0095\u0001\u0095\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096"+ - "\u0001\u0096\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097"+ - "\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097"+ - "\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0098\u0001\u0098\u0001\u0098"+ - "\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0099\u0001\u0099\u0001\u0099"+ - "\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u009a\u0001\u009a\u0001\u009a"+ - "\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a"+ - "\u0001\u009a\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b"+ - "\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b"+ - "\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c"+ - "\u0001\u009c\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d"+ - "\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009e\u0001\u009e"+ - "\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e"+ - "\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0001\u009f"+ - "\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0"+ - "\u0001\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1"+ - "\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2"+ - "\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3"+ - "\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3"+ - "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ - "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ - "\u0001\u00a4\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+ - "\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+ - "\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+ - "\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+ - "\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+ - "\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a6\u0001\u00a6\u0001\u00a6"+ - "\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6"+ - "\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a7\u0001\u00a7"+ - "\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7"+ - "\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a8"+ - "\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8"+ - "\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8"+ - "\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9"+ - "\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9"+ - "\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9"+ - "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+ - "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+ - "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+ - "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+ - "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa"+ - "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab"+ - "\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab"+ - "\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0001\u00ac"+ - "\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ad"+ - "\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad"+ - "\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ae"+ - "\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00af"+ - "\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00b0\u0001\u00b0"+ - "\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0"+ - "\u0001\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1"+ - "\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2"+ - "\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2"+ - "\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2"+ - "\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b3"+ - "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ - "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ - "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ - "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3"+ - "\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b4\u0001\u00b4\u0001\u00b4"+ - "\u0001\u00b4\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5"+ - "\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5"+ - "\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b7\u0001\u00b7"+ - "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ - "\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8"+ - "\u0001\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9"+ - "\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00ba\u0001\u00ba"+ - "\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba"+ - "\u0001\u00ba\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb"+ - "\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bc"+ - "\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc"+ - "\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bd\u0001\u00bd"+ - "\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+ - "\u0001\u00bd\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be"+ - "\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00bf\u0001\u00bf\u0001\u00bf"+ - "\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00c0"+ - "\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+ - "\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1"+ - "\u0001\u00c1\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2"+ - "\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c3"+ - "\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3"+ - "\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c4\u0001\u00c4"+ - "\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4"+ - "\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c5\u0001\u00c5\u0001\u00c5"+ - "\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c6"+ - "\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c7"+ - "\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c8"+ - "\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8"+ - "\u0001\u00c8\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9"+ - "\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca"+ - "\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00cb\u0001\u00cb\u0001\u00cb"+ - "\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb"+ - "\u0001\u00cb\u0001\u00cb\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc"+ - "\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cd\u0001\u00cd"+ - "\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd"+ - "\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00ce\u0001\u00ce\u0001\u00ce"+ - "\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce"+ - "\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00cf"+ - "\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf"+ - "\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00d0"+ - "\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0"+ - "\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d1\u0001\u00d1"+ - "\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1"+ - "\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2"+ - "\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2"+ - "\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2"+ - "\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d3\u0001\u00d3"+ - "\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3"+ - "\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4"+ - "\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d5"+ - "\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5"+ - "\u0001\u00d5\u0001\u00d5\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6"+ - "\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d7"+ - "\u0001\u00d7\u0001\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8"+ - "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d9\u0001\u00d9\u0001\u00d9"+ - "\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00da\u0001\u00da"+ - "\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00db\u0001\u00db\u0001\u00db"+ - "\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00dc"+ - "\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc"+ - "\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc"+ - "\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dd\u0001\u00dd"+ - "\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd"+ - "\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd"+ - "\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd"+ - "\u0001\u00dd\u0001\u00dd\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de"+ - "\u0001\u00de\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df"+ - "\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00e0\u0001\u00e0\u0001\u00e0"+ - "\u0001\u00e0\u0001\u00e0\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1"+ - "\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ - "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ - "\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3"+ - "\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e4\u0001\u00e4"+ - "\u0001\u00e4\u0001\u00e4\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5"+ - "\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e6"+ - "\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6"+ - "\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7"+ - "\u0001\u00e7\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8"+ - "\u0001\u00e8\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9"+ - "\u0001\u00e9\u0001\u00e9\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00ea"+ - "\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00ea"+ - "\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb"+ - "\u0001\u00eb\u0001\u00eb\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec"+ - "\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec"+ - "\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed"+ - "\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ee\u0001\u00ee"+ - "\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ef\u0001\u00ef\u0001\u00ef"+ - "\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00f0"+ - "\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0"+ - "\u0001\u00f0\u0001\u00f0\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1"+ - "\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f2\u0001\u00f2\u0001\u00f2"+ - "\u0001\u00f2\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+ - "\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f4\u0001\u00f4\u0001\u00f4"+ - "\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4"+ - "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5"+ - "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f6\u0001\u00f6"+ - "\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6"+ - "\u0001\u00f6\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7"+ - "\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f8\u0001\u00f8\u0001\u00f8"+ - "\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f9\u0001\u00f9\u0001\u00f9"+ - "\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00fa\u0001\u00fa\u0001\u00fa"+ - "\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fb\u0001\u00fb"+ - "\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fc"+ - "\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fd"+ - "\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fe"+ - "\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00ff"+ - "\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u0100"+ - "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ - "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0101\u0001\u0101\u0001\u0101"+ - "\u0001\u0101\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103"+ - "\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0104\u0001\u0104\u0001\u0104"+ - "\u0001\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001\u0105\u0001\u0105"+ - "\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105"+ - "\u0001\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0001\u0106"+ - "\u0001\u0106\u0001\u0106\u0001\u0107\u0001\u0107\u0001\u0107\u0001\u0107"+ - "\u0001\u0107\u0001\u0107\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108"+ - "\u0001\u0108\u0001\u0109\u0001\u0109\u0001\u0109\u0001\u0109\u0001\u0109"+ - "\u0001\u0109\u0001\u0109\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010a"+ - "\u0001\u010a\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ - "\u0001\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0001\u010c\u0001\u010c"+ - "\u0001\u010c\u0001\u010c\u0001\u010c\u0001\u010d\u0001\u010d\u0001\u010d"+ - "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010e\u0001\u010e"+ - "\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u010f"+ - "\u0001\u010f\u0001\u010f\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110"+ - "\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110"+ - "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0112\u0001\u0112"+ - "\u0001\u0112\u0001\u0112\u0001\u0112\u0001\u0112\u0001\u0112\u0001\u0113"+ - "\u0001\u0113\u0001\u0113\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114"+ - "\u0001\u0114\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115"+ - "\u0001\u0115\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116"+ - "\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0117\u0001\u0117\u0001\u0117"+ - "\u0001\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0001\u0117"+ - "\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118"+ - "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ - "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u011a\u0001\u011a\u0001\u011a"+ - "\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011b"+ - "\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b"+ - "\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c"+ - "\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011d\u0001\u011d"+ - "\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011e\u0001\u011e\u0001\u011e"+ - "\u0001\u011e\u0001\u011e\u0001\u011f\u0001\u011f\u0001\u011f\u0001\u011f"+ - "\u0001\u011f\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120"+ - "\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0121\u0001\u0121"+ - "\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0122"+ - "\u0001\u0122\u0001\u0122\u0001\u0122\u0001\u0122\u0001\u0122\u0001\u0123"+ - "\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123"+ - "\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0124\u0001\u0124\u0001\u0124"+ - "\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124"+ - "\u0001\u0124\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125"+ - "\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125"+ - "\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0126\u0001\u0126"+ - "\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126"+ - "\u0001\u0126\u0001\u0127\u0001\u0127\u0001\u0127\u0001\u0128\u0001\u0128"+ - "\u0001\u0128\u0001\u0128\u0001\u0128\u0001\u0128\u0001\u0128\u0001\u0128"+ - "\u0001\u0128\u0001\u0128\u0001\u0129\u0001\u0129\u0001\u0129\u0001\u0129"+ - "\u0001\u0129\u0001\u0129\u0001\u0129\u0001\u0129\u0001\u0129\u0001\u0129"+ - "\u0001\u012a\u0001\u012a\u0001\u012a\u0001\u012a\u0001\u012a\u0001\u012a"+ - "\u0001\u012b\u0001\u012b\u0001\u012b\u0001\u012b\u0001\u012b\u0001\u012b"+ - "\u0001\u012b\u0001\u012b\u0001\u012b\u0001\u012b\u0001\u012c\u0001\u012c"+ - "\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012d\u0001\u012d"+ - "\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d"+ - "\u0001\u012d\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e"+ - "\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e"+ - "\u0001\u012f\u0001\u012f\u0001\u012f\u0001\u012f\u0001\u012f\u0001\u012f"+ - "\u0001\u012f\u0001\u012f\u0001\u012f\u0001\u012f\u0001\u0130\u0001\u0130"+ - "\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0131\u0001\u0131"+ - "\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0132\u0001\u0132"+ - "\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0133\u0001\u0133"+ - "\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133"+ - "\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0134\u0001\u0134"+ - "\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0135"+ - "\u0001\u0135\u0001\u0135\u0001\u0135\u0001\u0135\u0001\u0135\u0001\u0135"+ - "\u0001\u0135\u0001\u0135\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136"+ - "\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136"+ - "\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0137\u0001\u0137\u0001\u0137"+ - "\u0001\u0137\u0001\u0137\u0001\u0137\u0001\u0137\u0001\u0137\u0001\u0138"+ - "\u0001\u0138\u0001\u0138\u0001\u0138\u0001\u0139\u0001\u0139\u0001\u0139"+ - "\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u013a"+ - "\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a"+ - "\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013b\u0001\u013b\u0001\u013b"+ - "\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b"+ - "\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013c\u0001\u013c"+ - "\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c"+ - "\u0001\u013c\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d"+ - "\u0001\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0001\u013e"+ - "\u0001\u013e\u0001\u013e\u0001\u013f\u0001\u013f\u0001\u013f\u0001\u0140"+ - "\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140"+ - "\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0141\u0001\u0141\u0001\u0141"+ - "\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0142"+ - "\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0143\u0001\u0143"+ - "\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0145\u0001\u0145"+ - "\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145"+ - "\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0146\u0001\u0146\u0001\u0146"+ - "\u0001\u0146\u0001\u0146\u0001\u0146\u0001\u0146\u0001\u0146\u0001\u0146"+ - "\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0147"+ - "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148"+ - "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148"+ - "\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149"+ - "\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u014a\u0001\u014a\u0001\u014a"+ - "\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014b\u0001\u014b\u0001\u014b"+ - "\u0001\u014b\u0001\u014b\u0001\u014c\u0001\u014c\u0001\u014c\u0001\u014c"+ - "\u0001\u014c\u0001\u014c\u0001\u014c\u0001\u014c\u0001\u014d\u0001\u014d"+ - "\u0001\u014d\u0001\u014d\u0001\u014d\u0001\u014d\u0001\u014d\u0001\u014d"+ - "\u0001\u014e\u0001\u014e\u0001\u014e\u0001\u014e\u0001\u014e\u0001\u014e"+ - "\u0001\u014f\u0001\u014f\u0001\u014f\u0001\u014f\u0001\u014f\u0001\u0150"+ - "\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150"+ - "\u0001\u0151\u0001\u0151\u0001\u0151\u0001\u0151\u0001\u0151\u0001\u0152"+ - "\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0153"+ - "\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0154\u0001\u0154"+ - "\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0155\u0001\u0155"+ - "\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0156"+ - "\u0001\u0156\u0001\u0156\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0157"+ - "\u0001\u0157\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158"+ - "\u0001\u0158\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159"+ - "\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u015a"+ - "\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a"+ - "\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a"+ - "\u0001\u015a\u0001\u015a\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b"+ - "\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015c"+ - "\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c"+ - "\u0001\u015c\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015d"+ - "\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e"+ - "\u0001\u015e\u0001\u015f\u0001\u015f\u0001\u015f\u0001\u015f\u0001\u015f"+ - "\u0001\u015f\u0001\u0160\u0001\u0160\u0001\u0161\u0001\u0161\u0001\u0161"+ - "\u0001\u0161\u0001\u0161\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162"+ - "\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163"+ - "\u0001\u0163\u0001\u0163\u0001\u0164\u0001\u0164\u0001\u0164\u0001\u0164"+ - "\u0001\u0164\u0001\u0164\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165"+ - "\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165"+ - "\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0166\u0001\u0166\u0001\u0166"+ - "\u0001\u0166\u0001\u0166\u0001\u0166\u0001\u0166\u0001\u0166\u0001\u0167"+ - "\u0001\u0167\u0001\u0167\u0001\u0167\u0001\u0168\u0001\u0168\u0001\u0168"+ - "\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168"+ - "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ - "\u0001\u0169\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016a"+ - "\u0001\u016a\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b"+ - "\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b"+ - "\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016c\u0001\u016c"+ - "\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c"+ - "\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c"+ - "\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c"+ - "\u0001\u016c\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016d"+ - "\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016d"+ - "\u0001\u016d\u0001\u016d\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e"+ - "\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016f\u0001\u016f\u0001\u016f"+ - "\u0001\u016f\u0001\u0170\u0001\u0170\u0001\u0170\u0001\u0170\u0001\u0170"+ - "\u0001\u0170\u0001\u0170\u0001\u0171\u0001\u0171\u0001\u0171\u0001\u0171"+ - "\u0001\u0171\u0001\u0171\u0001\u0171\u0001\u0171\u0001\u0171\u0001\u0172"+ - "\u0001\u0172\u0001\u0172\u0001\u0172\u0001\u0173\u0001\u0173\u0001\u0173"+ - "\u0001\u0173\u0001\u0173\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ - "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0175"+ - "\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0175"+ - "\u0001\u0176\u0001\u0176\u0001\u0176\u0001\u0176\u0001\u0176\u0001\u0176"+ - "\u0001\u0176\u0001\u0177\u0001\u0177\u0001\u0177\u0001\u0177\u0001\u0177"+ - "\u0001\u0177\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178"+ - "\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u017a"+ - "\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017a"+ - "\u0001\u017a\u0001\u017a\u0001\u017b\u0001\u017b\u0001\u017b\u0001\u017b"+ - "\u0001\u017b\u0001\u017b\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c"+ - "\u0001\u017c\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d"+ - "\u0001\u017d\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017e"+ - "\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017f\u0001\u017f"+ - "\u0001\u017f\u0001\u017f\u0001\u017f\u0001\u017f\u0001\u017f\u0001\u017f"+ - "\u0001\u0180\u0001\u0180\u0001\u0180\u0001\u0180\u0001\u0180\u0001\u0180"+ - "\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0181"+ - "\u0001\u0182\u0001\u0182\u0001\u0182\u0001\u0182\u0001\u0182\u0001\u0182"+ - "\u0001\u0182\u0001\u0182\u0001\u0183\u0001\u0183\u0001\u0183\u0001\u0183"+ - "\u0001\u0184\u0001\u0184\u0001\u0184\u0001\u0184\u0001\u0184\u0001\u0185"+ - "\u0001\u0185\u0001\u0185\u0001\u0186\u0001\u0186\u0001\u0186\u0001\u0186"+ - "\u0001\u0186\u0001\u0186\u0001\u0186\u0001\u0186\u0001\u0186\u0001\u0186"+ - "\u0001\u0186\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187"+ - "\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187"+ - "\u0001\u0187\u0001\u0187\u0001\u0188\u0001\u0188\u0001\u0188\u0001\u0188"+ - "\u0001\u0188\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189"+ - "\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u018a"+ - "\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a"+ - "\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018b\u0001\u018b"+ - "\u0001\u018b\u0001\u018b\u0001\u018c\u0001\u018c\u0001\u018c\u0001\u018c"+ - "\u0001\u018c\u0001\u018c\u0001\u018c\u0001\u018c\u0001\u018d\u0001\u018d"+ - "\u0001\u018d\u0001\u018d\u0001\u018d\u0001\u018d\u0001\u018d\u0001\u018e"+ - "\u0001\u018e\u0001\u018e\u0001\u018e\u0001\u018e\u0001\u018e\u0001\u018e"+ - "\u0001\u018e\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u018f"+ - "\u0001\u018f\u0001\u018f\u0001\u0190\u0001\u0190\u0001\u0190\u0001\u0190"+ - "\u0001\u0190\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0191"+ - "\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0192\u0001\u0192"+ - "\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0193"+ - "\u0001\u0193\u0001\u0193\u0001\u0193\u0001\u0193\u0001\u0193\u0001\u0194"+ - "\u0001\u0194\u0001\u0194\u0001\u0194\u0001\u0194\u0001\u0194\u0001\u0194"+ - "\u0001\u0195\u0001\u0195\u0001\u0195\u0001\u0195\u0001\u0195\u0001\u0195"+ - "\u0001\u0195\u0001\u0195\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0196"+ - "\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0197\u0001\u0197\u0001\u0197"+ - "\u0001\u0197\u0001\u0197\u0001\u0197\u0001\u0197\u0001\u0197\u0001\u0197"+ - "\u0001\u0197\u0001\u0197\u0001\u0197\u0001\u0197\u0001\u0198\u0001\u0198"+ - "\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0199"+ - "\u0001\u0199\u0001\u0199\u0001\u019a\u0001\u019a\u0001\u019a\u0001\u019a"+ - "\u0001\u019b\u0001\u019b\u0001\u019b\u0001\u019b\u0001\u019b\u0001\u019b"+ - "\u0001\u019b\u0001\u019c\u0001\u019c\u0001\u019c\u0001\u019c\u0001\u019c"+ - "\u0001\u019d\u0001\u019d\u0001\u019d\u0001\u019d\u0001\u019e\u0001\u019e"+ - "\u0001\u019e\u0001\u019f\u0001\u019f\u0001\u019f\u0001\u019f\u0001\u019f"+ - "\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a1"+ - "\u0001\u01a1\u0001\u01a1\u0001\u01a1\u0001\u01a1\u0001\u01a1\u0001\u01a1"+ - "\u0001\u01a1\u0001\u01a1\u0001\u01a1\u0001\u01a2\u0001\u01a2\u0001\u01a2"+ - "\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2"+ - "\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3"+ - "\u0001\u01a3\u0001\u01a4\u0001\u01a4\u0001\u01a4\u0001\u01a4\u0001\u01a4"+ - "\u0001\u01a4\u0001\u01a4\u0001\u01a4\u0001\u01a5\u0001\u01a5\u0001\u01a5"+ - "\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6"+ - "\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7"+ - "\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a8\u0001\u01a8\u0001\u01a8"+ - "\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8"+ - "\u0001\u01a8\u0001\u01a8\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9"+ - "\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01aa\u0001\u01aa\u0001\u01aa"+ - "\u0001\u01aa\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab"+ - "\u0001\u01ab\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac"+ - "\u0001\u01ac\u0001\u01ac\u0001\u01ad\u0001\u01ad\u0001\u01ad\u0001\u01ad"+ - "\u0001\u01ad\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae"+ - "\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01af\u0001\u01af"+ - "\u0001\u01af\u0001\u01af\u0001\u01af\u0001\u01af\u0001\u01af\u0001\u01af"+ - "\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0"+ - "\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b1"+ - "\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b2"+ - "\u0001\u01b2\u0001\u01b2\u0001\u01b2\u0001\u01b3\u0001\u01b3\u0001\u01b3"+ - "\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3"+ - "\u0001\u01b3\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4"+ - "\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4"+ - "\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b5\u0001\u01b5"+ - "\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5"+ - "\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5"+ - "\u0001\u01b5\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6"+ - "\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6"+ - "\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6"+ - "\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6"+ - "\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b7\u0001\u01b7"+ - "\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7"+ - "\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7"+ - "\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7"+ - "\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7"+ - "\u0001\u01b7\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8"+ - "\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8"+ - "\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8"+ - "\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8"+ - "\u0001\u01b8\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9"+ - "\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9"+ - "\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9"+ - "\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9"+ - "\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01ba\u0001\u01ba\u0001\u01ba"+ - "\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01ba"+ - "\u0001\u01ba\u0001\u01ba\u0001\u01bb\u0001\u01bb\u0001\u01bb\u0001\u01bb"+ - "\u0001\u01bb\u0001\u01bb\u0001\u01bb\u0001\u01bc\u0001\u01bc\u0001\u01bc"+ - "\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0001\u01bd"+ - "\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01bd"+ - "\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01be\u0001\u01be\u0001\u01be"+ - "\u0001\u01be\u0001\u01be\u0001\u01be\u0001\u01be\u0001\u01bf\u0001\u01bf"+ - "\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001\u01bf"+ - "\u0001\u01bf\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0"+ - "\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1"+ - "\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1"+ - "\u0001\u01c1\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2"+ - "\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2"+ - "\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c3"+ - "\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3"+ - "\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3"+ - "\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c4\u0001\u01c4\u0001\u01c4"+ - "\u0001\u01c4\u0001\u01c4\u0001\u01c4\u0001\u01c4\u0001\u01c4\u0001\u01c5"+ - "\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c6"+ - "\u0001\u01c6\u0001\u01c6\u0001\u01c6\u0001\u01c6\u0001\u01c6\u0001\u01c7"+ - "\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001\u01c8\u0001\u01c8\u0001\u01c8"+ - "\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c8"+ - "\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9"+ - "\u0001\u01c9\u0001\u01c9\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca"+ - "\u0001\u01ca\u0001\u01ca\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb"+ - "\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb"+ - "\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cc"+ - "\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cd\u0001\u01cd"+ - "\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01ce"+ - "\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce"+ - "\u0001\u01ce\u0001\u01ce\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001\u01cf"+ - "\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001\u01d0\u0001\u01d0"+ - "\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0"+ - "\u0001\u01d0\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d1"+ - "\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d2\u0001\u01d2"+ - "\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2"+ - "\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3"+ - "\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4"+ - "\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d5"+ - "\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5"+ - "\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d6\u0001\u01d6"+ - "\u0001\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d6"+ - "\u0001\u01d6\u0001\u01d6\u0001\u01d7\u0001\u01d7\u0001\u01d7\u0001\u01d7"+ - "\u0001\u01d7\u0001\u01d7\u0001\u01d7\u0001\u01d8\u0001\u01d8\u0001\u01d8"+ - "\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0001\u01d8"+ - "\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0001\u01d9\u0001\u01d9\u0001\u01d9"+ - "\u0001\u01d9\u0001\u01d9\u0001\u01d9\u0001\u01da\u0001\u01da\u0001\u01da"+ - "\u0001\u01da\u0001\u01da\u0001\u01da\u0001\u01db\u0001\u01db\u0001\u01db"+ - "\u0001\u01db\u0001\u01db\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dc"+ - "\u0001\u01dc\u0001\u01dd\u0001\u01dd\u0001\u01dd\u0001\u01dd\u0001\u01dd"+ - "\u0001\u01dd\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de"+ - "\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df"+ - "\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01e0\u0001\u01e0\u0001\u01e0"+ - "\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e1"+ - "\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1"+ - "\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e2\u0001\u01e2\u0001\u01e2"+ - "\u0001\u01e2\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3"+ - "\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3"+ - "\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4"+ - "\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4"+ - "\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5"+ - "\u0001\u01e5\u0001\u01e5\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6"+ - "\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6"+ - "\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7"+ - "\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e8\u0001\u01e8"+ - "\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8"+ - "\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e9\u0001\u01e9\u0001\u01e9"+ - "\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9"+ - "\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9"+ - "\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea"+ - "\u0001\u01ea\u0001\u01ea\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb"+ - "\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01eb"+ - "\u0001\u01eb\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec"+ - "\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ed\u0001\u01ed"+ - "\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed"+ - "\u0001\u01ed\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee"+ - "\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ef\u0001\u01ef"+ - "\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef"+ - "\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0"+ - "\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f1\u0001\u01f1\u0001\u01f1"+ - "\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f2"+ - "\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2"+ - "\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3"+ - "\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f4"+ - "\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4"+ - "\u0001\u01f4\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f5"+ - "\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f6\u0001\u01f6\u0001\u01f6"+ - "\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f7\u0001\u01f7\u0001\u01f7"+ - "\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f8"+ - "\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8"+ - "\u0001\u01f8\u0001\u01f8\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01f9"+ - "\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01fa\u0001\u01fa\u0001\u01fa"+ - "\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fb\u0001\u01fb"+ - "\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb"+ - "\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb"+ - "\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb"+ - "\u0001\u01fb\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc"+ - "\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc"+ - "\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fd"+ - "\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd"+ - "\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd"+ - "\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd"+ - "\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fe\u0001\u01fe\u0001\u01fe"+ - "\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe"+ - "\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe"+ - "\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01ff\u0001\u01ff\u0001\u01ff"+ - "\u0001\u01ff\u0001\u01ff\u0001\u01ff\u0001\u01ff\u0001\u01ff\u0001\u01ff"+ - "\u0001\u01ff\u0001\u0200\u0001\u0200\u0001\u0200\u0001\u0200\u0001\u0200"+ - "\u0001\u0200\u0001\u0200\u0001\u0200\u0001\u0201\u0001\u0201\u0001\u0201"+ - "\u0001\u0201\u0001\u0201\u0001\u0201\u0001\u0201\u0001\u0202\u0001\u0202"+ - "\u0001\u0202\u0001\u0202\u0001\u0202\u0001\u0202\u0001\u0203\u0001\u0203"+ - "\u0001\u0203\u0001\u0203\u0001\u0203\u0001\u0204\u0001\u0204\u0001\u0204"+ - "\u0001\u0204\u0001\u0204\u0001\u0204\u0001\u0204\u0001\u0204\u0001\u0204"+ - "\u0001\u0205\u0001\u0205\u0001\u0205\u0001\u0205\u0001\u0205\u0001\u0205"+ - "\u0001\u0205\u0001\u0206\u0001\u0206\u0001\u0206\u0001\u0206\u0001\u0206"+ - "\u0001\u0206\u0001\u0206\u0001\u0206\u0001\u0207\u0001\u0207\u0001\u0207"+ - "\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0207"+ - "\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0207"+ - "\u0001\u0207\u0001\u0208\u0001\u0208\u0001\u0208\u0001\u0208\u0001\u0208"+ - "\u0001\u0208\u0001\u0208\u0001\u0208\u0001\u0208\u0001\u0208\u0001\u0208"+ - "\u0001\u0208\u0001\u0208\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u0209"+ - "\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u0209"+ - "\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u020a"+ - "\u0001\u020a\u0001\u020a\u0001\u020a\u0001\u020b\u0001\u020b\u0001\u020b"+ - "\u0001\u020b\u0001\u020b\u0001\u020b\u0001\u020b\u0001\u020b\u0001\u020b"+ - "\u0001\u020b\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c"+ - "\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c"+ - "\u0001\u020d\u0001\u020d\u0001\u020d\u0001\u020d\u0001\u020d\u0001\u020e"+ - "\u0001\u020e\u0001\u020e\u0001\u020e\u0001\u020e\u0001\u020f\u0001\u020f"+ - "\u0001\u020f\u0001\u020f\u0001\u020f\u0001\u020f\u0001\u020f\u0001\u020f"+ - "\u0001\u020f\u0001\u020f\u0001\u0210\u0001\u0210\u0001\u0210\u0001\u0210"+ - "\u0001\u0210\u0001\u0210\u0001\u0211\u0001\u0211\u0001\u0211\u0001\u0211"+ - "\u0001\u0211\u0001\u0211\u0001\u0211\u0001\u0212\u0001\u0212\u0001\u0212"+ - "\u0001\u0212\u0001\u0212\u0001\u0212\u0001\u0212\u0001\u0212\u0001\u0212"+ - "\u0001\u0212\u0001\u0212\u0001\u0212\u0001\u0213\u0001\u0213\u0001\u0213"+ - "\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0214\u0001\u0214\u0001\u0214"+ - "\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0214"+ - "\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0215"+ - "\u0001\u0215\u0001\u0215\u0001\u0215\u0001\u0215\u0001\u0215\u0001\u0215"+ - "\u0001\u0215\u0001\u0215\u0001\u0215\u0001\u0215\u0001\u0216\u0001\u0216"+ - "\u0001\u0216\u0001\u0216\u0001\u0216\u0001\u0216\u0001\u0216\u0001\u0216"+ - "\u0001\u0216\u0001\u0216\u0001\u0216\u0001\u0216\u0001\u0216\u0001\u0217"+ - "\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0217"+ - "\u0001\u0218\u0001\u0218\u0001\u0218\u0001\u0218\u0001\u0218\u0001\u0218"+ - "\u0001\u0218\u0001\u0219\u0001\u0219\u0001\u0219\u0001\u0219\u0001\u0219"+ - "\u0001\u0219\u0001\u0219\u0001\u021a\u0001\u021a\u0001\u021a\u0001\u021a"+ - "\u0001\u021a\u0001\u021a\u0001\u021a\u0001\u021a\u0001\u021b\u0001\u021b"+ - "\u0001\u021b\u0001\u021b\u0001\u021b\u0001\u021b\u0001\u021b\u0001\u021b"+ - "\u0001\u021b\u0001\u021c\u0001\u021c\u0001\u021c\u0001\u021c\u0001\u021c"+ - "\u0001\u021c\u0001\u021c\u0001\u021d\u0001\u021d\u0001\u021d\u0001\u021d"+ - "\u0001\u021d\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e"+ - "\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021f"+ - "\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f"+ - "\u0001\u021f\u0001\u021f\u0001\u0220\u0001\u0220\u0001\u0220\u0001\u0220"+ - "\u0001\u0220\u0001\u0220\u0001\u0220\u0001\u0220\u0001\u0220\u0001\u0220"+ - "\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221"+ - "\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221"+ - "\u0001\u0221\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222"+ - "\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222"+ - "\u0001\u0222\u0001\u0223\u0001\u0223\u0001\u0223\u0001\u0223\u0001\u0223"+ - "\u0001\u0223\u0001\u0223\u0001\u0223\u0001\u0224\u0001\u0224\u0001\u0224"+ - "\u0001\u0224\u0001\u0224\u0001\u0224\u0001\u0224\u0001\u0224\u0001\u0224"+ - "\u0001\u0224\u0001\u0224\u0001\u0224\u0001\u0224\u0001\u0225\u0001\u0225"+ - "\u0001\u0225\u0001\u0225\u0001\u0226\u0001\u0226\u0001\u0226\u0001\u0226"+ - "\u0001\u0226\u0001\u0226\u0001\u0227\u0001\u0227\u0001\u0227\u0001\u0227"+ - "\u0001\u0227\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228"+ - "\u0001\u0228\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229"+ - "\u0001\u022a\u0001\u022a\u0001\u022a\u0001\u022a\u0001\u022a\u0001\u022a"+ - "\u0001\u022a\u0001\u022a\u0001\u022b\u0001\u022b\u0001\u022b\u0001\u022b"+ - "\u0001\u022b\u0001\u022b\u0001\u022b\u0001\u022c\u0001\u022c\u0001\u022c"+ - "\u0001\u022c\u0001\u022c\u0001\u022d\u0001\u022d\u0001\u022d\u0001\u022d"+ - "\u0001\u022d\u0001\u022e\u0001\u022e\u0001\u022e\u0001\u022e\u0001\u022e"+ - "\u0001\u022e\u0001\u022e\u0001\u022e\u0001\u022e\u0001\u022f\u0001\u022f"+ - "\u0001\u022f\u0001\u022f\u0001\u022f\u0001\u022f\u0001\u022f\u0001\u022f"+ - "\u0001\u022f\u0001\u0230\u0001\u0230\u0001\u0230\u0001\u0230\u0001\u0230"+ - "\u0001\u0231\u0001\u0231\u0001\u0231\u0001\u0231\u0001\u0231\u0001\u0231"+ - "\u0001\u0231\u0001\u0232\u0001\u0232\u0001\u0232\u0001\u0232\u0001\u0232"+ - "\u0001\u0232\u0001\u0233\u0001\u0233\u0001\u0233\u0001\u0233\u0001\u0233"+ - "\u0001\u0233\u0001\u0233\u0001\u0233\u0001\u0233\u0001\u0234\u0001\u0234"+ - "\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234"+ - "\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234"+ - "\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235"+ - "\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235"+ - "\u0001\u0235\u0001\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001\u0237"+ - "\u0001\u0237\u0001\u0237\u0001\u0237\u0001\u0237\u0001\u0237\u0001\u0237"+ - "\u0001\u0237\u0001\u0238\u0001\u0238\u0001\u0238\u0001\u0238\u0001\u0238"+ - "\u0001\u0238\u0001\u0238\u0001\u0238\u0001\u0238\u0001\u0239\u0001\u0239"+ - "\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u0239"+ - "\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u023a"+ - "\u0001\u023a\u0001\u023a\u0001\u023a\u0001\u023a\u0001\u023a\u0001\u023a"+ - "\u0001\u023a\u0001\u023a\u0001\u023b\u0001\u023b\u0001\u023b\u0001\u023b"+ - "\u0001\u023b\u0001\u023b\u0001\u023b\u0001\u023b\u0001\u023b\u0001\u023b"+ - "\u0001\u023b\u0001\u023c\u0001\u023c\u0001\u023c\u0001\u023c\u0001\u023c"+ - "\u0001\u023d\u0001\u023d\u0001\u023d\u0001\u023d\u0001\u023d\u0001\u023d"+ - "\u0001\u023d\u0001\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0001\u023e"+ - "\u0001\u023e\u0001\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001\u023f"+ - "\u0001\u023f\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240"+ - "\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0241"+ - "\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0241"+ - "\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242"+ - "\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0243"+ - "\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243"+ - "\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0244\u0001\u0244"+ - "\u0001\u0244\u0001\u0244\u0001\u0244\u0001\u0244\u0001\u0244\u0001\u0244"+ - "\u0001\u0244\u0001\u0244\u0001\u0244\u0001\u0244\u0001\u0245\u0001\u0245"+ - "\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0246\u0001\u0246"+ - "\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0247"+ - "\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247"+ - "\u0001\u0247\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248"+ - "\u0001\u0248\u0001\u0248\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249"+ - "\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249\u0001\u0249"+ - "\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024a"+ - "\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b"+ - "\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b"+ - "\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024c\u0001\u024c"+ - "\u0001\u024c\u0001\u024c\u0001\u024c\u0001\u024c\u0001\u024c\u0001\u024c"+ - "\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024d"+ - "\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024d"+ - "\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e"+ - "\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e"+ - "\u0001\u024e\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f"+ - "\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u0250"+ - "\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0251\u0001\u0251\u0001\u0251"+ - "\u0001\u0251\u0001\u0251\u0001\u0251\u0001\u0251\u0001\u0251\u0001\u0251"+ - "\u0001\u0251\u0001\u0252\u0001\u0252\u0001\u0252\u0001\u0252\u0001\u0252"+ - "\u0001\u0252\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0253"+ - "\u0001\u0253\u0001\u0253\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0254"+ - "\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0254"+ - "\u0001\u0254\u0001\u0254\u0001\u0255\u0001\u0255\u0001\u0255\u0001\u0255"+ - "\u0001\u0255\u0001\u0255\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0256"+ - "\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0256"+ - "\u0001\u0256\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0257"+ - "\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0257"+ - "\u0001\u0257\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0258"+ - "\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0258"+ - "\u0001\u0259\u0001\u0259\u0001\u0259\u0001\u0259\u0001\u0259\u0001\u025a"+ - "\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a"+ - "\u0001\u025a\u0001\u025a\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b"+ - "\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b"+ - "\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c"+ - "\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025d\u0001\u025d"+ - "\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025e\u0001\u025e\u0001\u025e"+ - "\u0001\u025e\u0001\u025e\u0001\u025f\u0001\u025f\u0001\u025f\u0001\u025f"+ - "\u0001\u025f\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260"+ - "\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0261"+ - "\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0262\u0001\u0262"+ - "\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262"+ - "\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262"+ - "\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263"+ - "\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263"+ - "\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0264\u0001\u0264"+ - "\u0001\u0264\u0001\u0264\u0001\u0264\u0001\u0264\u0001\u0264\u0001\u0265"+ - "\u0001\u0265\u0001\u0265\u0001\u0266\u0001\u0266\u0001\u0266\u0001\u0266"+ - "\u0001\u0266\u0001\u0266\u0001\u0267\u0001\u0267\u0001\u0267\u0001\u0267"+ - "\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268"+ - "\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268"+ - "\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0269\u0001\u0269"+ - "\u0001\u0269\u0001\u0269\u0001\u0269\u0001\u0269\u0001\u0269\u0001\u0269"+ - "\u0001\u0269\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026a"+ - "\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026a"+ - "\u0001\u026a\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b"+ - "\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b"+ - "\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b"+ - "\u0001\u026b\u0001\u026b\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c"+ - "\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c"+ - "\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c"+ - "\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026c"+ - "\u0001\u026c\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d"+ - "\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d"+ - "\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d"+ - "\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d\u0001\u026d"+ - "\u0001\u026d\u0001\u026d\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e"+ - "\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e"+ - "\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f"+ - "\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u0270"+ - "\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270"+ - "\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0271\u0001\u0271\u0001\u0271"+ - "\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271"+ - "\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0272\u0001\u0272\u0001\u0272"+ - "\u0001\u0272\u0001\u0272\u0001\u0272\u0001\u0273\u0001\u0273\u0001\u0273"+ - "\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0274"+ - "\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274"+ - "\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274"+ - "\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0275\u0001\u0275\u0001\u0275"+ - "\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275"+ - "\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0276\u0001\u0276"+ - "\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276"+ - "\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276"+ - "\u0001\u0276\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277"+ - "\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0279"+ - "\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279"+ - "\u0001\u0279\u0001\u0279\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027a"+ - "\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027b\u0001\u027b"+ - "\u0001\u027b\u0001\u027b\u0001\u027b\u0001\u027c\u0001\u027c\u0001\u027c"+ - "\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027d"+ - "\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027d"+ - "\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027e\u0001\u027e\u0001\u027e"+ - "\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e"+ - "\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027f\u0001\u027f\u0001\u027f"+ - "\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u0280\u0001\u0280\u0001\u0280"+ - "\u0001\u0280\u0001\u0280\u0001\u0280\u0001\u0280\u0001\u0280\u0001\u0280"+ - "\u0001\u0280\u0001\u0280\u0001\u0280\u0001\u0281\u0001\u0281\u0001\u0281"+ - "\u0001\u0281\u0001\u0281\u0001\u0281\u0001\u0282\u0001\u0282\u0001\u0282"+ - "\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0283\u0001\u0283"+ - "\u0001\u0283\u0001\u0283\u0001\u0283\u0001\u0283\u0001\u0283\u0001\u0283"+ - "\u0001\u0284\u0001\u0284\u0001\u0284\u0001\u0284\u0001\u0284\u0001\u0284"+ - "\u0001\u0284\u0001\u0284\u0001\u0284\u0001\u0285\u0001\u0285\u0001\u0285"+ - "\u0001\u0285\u0001\u0285\u0001\u0285\u0001\u0285\u0001\u0285\u0001\u0285"+ - "\u0001\u0286\u0001\u0286\u0001\u0286\u0001\u0286\u0001\u0286\u0001\u0286"+ - "\u0001\u0286\u0001\u0286\u0001\u0287\u0001\u0287\u0001\u0287\u0001\u0287"+ - "\u0001\u0287\u0001\u0287\u0001\u0287\u0001\u0288\u0001\u0288\u0001\u0288"+ - "\u0001\u0288\u0001\u0288\u0001\u0288\u0001\u0289\u0001\u0289\u0001\u0289"+ - "\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u028a\u0001\u028a"+ - "\u0001\u028a\u0001\u028a\u0001\u028a\u0001\u028a\u0001\u028b\u0001\u028b"+ - "\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028c\u0001\u028c"+ - "\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028d\u0001\u028d\u0001\u028d"+ - "\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d"+ - "\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d"+ - "\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d"+ - "\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028e"+ - "\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e"+ - "\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e"+ - "\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e"+ - "\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028f\u0001\u028f"+ - "\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f"+ - "\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f"+ - "\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f"+ + "E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001G\u0001G\u0001G\u0001"+ + "G\u0001G\u0001G\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001I\u0001"+ + "I\u0001I\u0001I\u0001I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001K\u0001"+ + "K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001L\u0001"+ + "L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001M\u0001"+ + "M\u0001M\u0001M\u0001M\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001"+ + "N\u0001N\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001"+ + "P\u0001P\u0001P\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ + "Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001R\u0001"+ + "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ + "R\u0001S\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001T\u0001T\u0001"+ + "U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001V\u0001V\u0001V\u0001"+ + "W\u0001W\u0001W\u0001W\u0001W\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001"+ + "Y\u0001Y\u0001Y\u0001Y\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ + "Z\u0001Z\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001_\u0001"+ + "_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001"+ + "_\u0001_\u0001`\u0001`\u0001`\u0001`\u0001`\u0001a\u0001a\u0001a\u0001"+ + "a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001b\u0001b\u0001b\u0001"+ + "b\u0001b\u0001b\u0001c\u0001c\u0001c\u0001c\u0001c\u0001d\u0001d\u0001"+ + "d\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001"+ + "f\u0001f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001g\u0001g\u0001g\u0001"+ + "g\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001i\u0001i\u0001"+ + "i\u0001i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001k\u0001"+ + "k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001l\u0001l\u0001"+ + "l\u0001l\u0001l\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001n\u0001"+ + "n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001o\u0001o\u0001o\u0001o\u0001"+ + "o\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+ + "p\u0001p\u0001p\u0001p\u0001p\u0001q\u0001q\u0001q\u0001q\u0001q\u0001"+ + "q\u0001q\u0001r\u0001r\u0001r\u0001r\u0001r\u0001r\u0001r\u0001r\u0001"+ + "r\u0001r\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001"+ + "s\u0001s\u0001s\u0001s\u0001s\u0001t\u0001t\u0001t\u0001t\u0001t\u0001"+ + "t\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001"+ + "u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001v\u0001"+ + "v\u0001v\u0001v\u0001w\u0001w\u0001w\u0001w\u0001w\u0001x\u0001x\u0001"+ + "x\u0001x\u0001x\u0001x\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001"+ + "z\u0001z\u0001z\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001"+ + "|\u0001|\u0001|\u0001|\u0001|\u0001}\u0001}\u0001}\u0001}\u0001}\u0001"+ + "~\u0001~\u0001~\u0001~\u0001~\u0001\u007f\u0001\u007f\u0001\u007f\u0001"+ + "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u0080\u0001"+ + "\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001"+ + "\u0080\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001"+ + "\u0081\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001"+ + "\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001"+ + "\u0083\u0001\u0083\u0001\u0083\u0001\u0084\u0001\u0084\u0001\u0084\u0001"+ + "\u0084\u0001\u0084\u0001\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001"+ + "\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0086\u0001"+ + "\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001"+ + "\u0086\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001"+ + "\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001"+ + "\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0089\u0001\u0089\u0001"+ + "\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u008a\u0001"+ + "\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001"+ + "\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c\u0001"+ + "\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008d\u0001\u008d\u0001"+ + "\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008e\u0001\u008e\u0001"+ + "\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001"+ + "\u008e\u0001\u008e\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001"+ + "\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+ + "\u0090\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001"+ + "\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+ + "\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+ + "\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+ + "\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0094\u0001"+ + "\u0094\u0001\u0094\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+ + "\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+ + "\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001"+ + "\u0096\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097\u0001\u0097\u0001"+ + "\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0098\u0001\u0098\u0001"+ + "\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0099\u0001\u0099\u0001"+ + "\u0099\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001\u009a\u0001"+ + "\u009a\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001"+ + "\u009b\u0001\u009b\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001"+ + "\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009d\u0001\u009d\u0001"+ + "\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001"+ + "\u009d\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001"+ + "\u009e\u0001\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0001\u009f\u0001"+ + "\u009f\u0001\u009f\u0001\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001"+ + "\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001"+ + "\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001"+ + "\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+ + "\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+ + "\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001"+ + "\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001"+ + "\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001"+ + "\u00a4\u0001\u00a4\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001"+ + "\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a6\u0001\u00a6\u0001"+ + "\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001"+ + "\u00a6\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001"+ + "\u00a7\u0001\u00a7\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001"+ + "\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001"+ + "\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001"+ + "\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001"+ + "\u00a9\u0001\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001"+ + "\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001"+ + "\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ + "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ + "\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001"+ + "\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+ + "\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001"+ + "\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001"+ + "\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00af\u0001"+ + "\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00b0\u0001\u00b0\u0001"+ + "\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001"+ + "\u00b1\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001"+ + "\u00b2\u0001\u00b2\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001"+ + "\u00b3\u0001\u00b3\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001"+ + "\u00b4\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001"+ + "\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b6\u0001\u00b6\u0001"+ + "\u00b6\u0001\u00b6\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001"+ + "\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001"+ + "\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001"+ + "\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001"+ + "\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001"+ + "\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001"+ + "\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001"+ + "\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bc\u0001"+ + "\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0001"+ + "\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001"+ + "\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00be\u0001\u00be\u0001"+ + "\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001"+ + "\u00be\u0001\u00be\u0001\u00be\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001"+ + "\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001"+ + "\u00bf\u0001\u00bf\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001"+ + "\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c1\u0001\u00c1\u0001"+ + "\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001"+ + "\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001"+ + "\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001"+ + "\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c4\u0001\u00c4\u0001"+ + "\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c5\u0001"+ + "\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c6\u0001\u00c6\u0001"+ + "\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001"+ + "\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c8\u0001\u00c8\u0001"+ + "\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001"+ + "\u00c8\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001"+ + "\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00ca\u0001"+ + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00cb\u0001\u00cb\u0001"+ + "\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cc\u0001"+ + "\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cd\u0001"+ + "\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001"+ + "\u00cd\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001"+ + "\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00cf\u0001"+ + "\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001"+ + "\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001"+ + "\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d1\u0001"+ + "\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001"+ + "\u00d1\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001"+ + "\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d3\u0001"+ + "\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001"+ + "\u00d3\u0001\u00d3\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+ + "\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001"+ + "\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001"+ + "\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001"+ + "\u00d6\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001"+ + "\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001"+ + "\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001"+ + "\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001"+ + "\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00db\u0001\u00db\u0001"+ + "\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00dc\u0001"+ + "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ + "\u00dc\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001"+ + "\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00de\u0001\u00de\u0001\u00de\u0001"+ + "\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00df\u0001\u00df\u0001"+ + "\u00df\u0001\u00df\u0001\u00df\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001"+ + "\u00e0\u0001\u00e0\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001"+ + "\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e2\u0001"+ + "\u00e2\u0001\u00e2\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001"+ + "\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001"+ + "\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001"+ + "\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001"+ + "\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001\u00e7\u0001"+ + "\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001"+ + "\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ + "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001"+ + "\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00ea\u0001"+ + "\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0001"+ + "\u00ea\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001"+ + "\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00ec\u0001\u00ec\u0001"+ + "\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ec\u0001\u00ed\u0001"+ + "\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001"+ + "\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0001\u00ee\u0001"+ + "\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0001"+ + "\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001"+ + "\u00ef\u0001\u00ef\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001"+ + "\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f1\u0001\u00f1\u0001"+ + "\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001"+ + "\u00f1\u0001\u00f1\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001"+ + "\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001"+ + "\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0001"+ + "\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001"+ + "\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001"+ + "\u00f6\u0001\u00f6\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001"+ + "\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001"+ + "\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001"+ + "\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001"+ + "\u00f9\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001"+ + "\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001"+ + "\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001"+ + "\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001"+ + "\u00fd\u0001\u00fd\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001"+ + "\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00ff\u0001\u00ff\u0001"+ + "\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u0100\u0001\u0100\u0001"+ + "\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001"+ + "\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001"+ + "\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001"+ + "\u0101\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001"+ + "\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0103\u0001\u0103\u0001"+ + "\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0104\u0001\u0104\u0001"+ + "\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001\u0104\u0001\u0105\u0001"+ + "\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001"+ + "\u0105\u0001\u0105\u0001\u0106\u0001\u0106\u0001\u0106\u0001\u0106\u0001"+ + "\u0106\u0001\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001\u0107\u0001"+ + "\u0107\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001"+ + "\u0109\u0001\u0109\u0001\u0109\u0001\u0109\u0001\u0109\u0001\u010a\u0001"+ + "\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010a\u0001\u010b\u0001"+ + "\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010c\u0001\u010c\u0001"+ + "\u010c\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001"+ + "\u010d\u0001\u010d\u0001\u010d\u0001\u010e\u0001\u010e\u0001\u010e\u0001"+ + "\u010e\u0001\u010e\u0001\u010e\u0001\u010e\u0001\u010f\u0001\u010f\u0001"+ + "\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u010f\u0001\u0110\u0001"+ + "\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0111\u0001"+ + "\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001"+ + "\u0112\u0001\u0112\u0001\u0112\u0001\u0113\u0001\u0113\u0001\u0113\u0001"+ + "\u0113\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001"+ + "\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001"+ + "\u0115\u0001\u0115\u0001\u0115\u0001\u0116\u0001\u0116\u0001\u0116\u0001"+ + "\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0117\u0001\u0117\u0001"+ + "\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0001\u0117\u0001"+ + "\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001"+ + "\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001"+ + "\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001\u011a\u0001"+ + "\u011a\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0001\u011b\u0001"+ + "\u011b\u0001\u011b\u0001\u011b\u0001\u011c\u0001\u011c\u0001\u011c\u0001"+ + "\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001\u011c\u0001"+ + "\u011c\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011d\u0001"+ + "\u011d\u0001\u011d\u0001\u011d\u0001\u011e\u0001\u011e\u0001\u011e\u0001"+ + "\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001"+ + "\u011f\u0001\u011f\u0001\u011f\u0001\u011f\u0001\u011f\u0001\u011f\u0001"+ + "\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001"+ + "\u0120\u0001\u0120\u0001\u0120\u0001\u0120\u0001\u0121\u0001\u0121\u0001"+ + "\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001"+ + "\u0122\u0001\u0122\u0001\u0122\u0001\u0122\u0001\u0122\u0001\u0122\u0001"+ + "\u0122\u0001\u0122\u0001\u0122\u0001\u0123\u0001\u0123\u0001\u0123\u0001"+ + "\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001"+ + "\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001"+ + "\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001"+ + "\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0125\u0001\u0126\u0001"+ + "\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001"+ + "\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0127\u0001\u0127\u0001"+ + "\u0127\u0001\u0127\u0001\u0127\u0001\u0127\u0001\u0127\u0001\u0127\u0001"+ + "\u0127\u0001\u0127\u0001\u0128\u0001\u0128\u0001\u0128\u0001\u0128\u0001"+ + "\u0128\u0001\u0128\u0001\u0128\u0001\u0128\u0001\u0129\u0001\u0129\u0001"+ + "\u0129\u0001\u0129\u0001\u0129\u0001\u0129\u0001\u012a\u0001\u012a\u0001"+ + "\u012a\u0001\u012a\u0001\u012a\u0001\u012a\u0001\u012b\u0001\u012b\u0001"+ + "\u012b\u0001\u012b\u0001\u012b\u0001\u012c\u0001\u012c\u0001\u012c\u0001"+ + "\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001"+ + "\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001"+ + "\u012d\u0001\u012d\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001"+ + "\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e\u0001"+ + "\u012f\u0001\u012f\u0001\u012f\u0001\u012f\u0001\u0130\u0001\u0130\u0001"+ + "\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001\u0130\u0001"+ + "\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001\u0131\u0001"+ + "\u0131\u0001\u0131\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001"+ + "\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0132\u0001\u0133\u0001"+ + "\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001"+ + "\u0133\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001"+ + "\u0134\u0001\u0134\u0001\u0135\u0001\u0135\u0001\u0135\u0001\u0135\u0001"+ + "\u0135\u0001\u0135\u0001\u0135\u0001\u0135\u0001\u0135\u0001\u0135\u0001"+ + "\u0135\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001\u0136\u0001"+ + "\u0136\u0001\u0136\u0001\u0136\u0001\u0137\u0001\u0137\u0001\u0137\u0001"+ + "\u0137\u0001\u0137\u0001\u0137\u0001\u0137\u0001\u0137\u0001\u0138\u0001"+ + "\u0138\u0001\u0138\u0001\u0138\u0001\u0138\u0001\u0138\u0001\u0139\u0001"+ + "\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001"+ + "\u0139\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001"+ + "\u013a\u0001\u013a\u0001\u013a\u0001\u013a\u0001\u013b\u0001\u013b\u0001"+ + "\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001\u013b\u0001"+ + "\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001\u013c\u0001"+ + "\u013c\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0001"+ + "\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0001"+ + "\u013e\u0001\u013e\u0001\u013e\u0001\u013f\u0001\u013f\u0001\u013f\u0001"+ + "\u013f\u0001\u013f\u0001\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0001"+ + "\u0140\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001"+ + "\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0141\u0001\u0142\u0001"+ + "\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001\u0142\u0001"+ + "\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001"+ + "\u0143\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001\u0144\u0001"+ + "\u0144\u0001\u0144\u0001\u0145\u0001\u0145\u0001\u0145\u0001\u0145\u0001"+ + "\u0145\u0001\u0145\u0001\u0145\u0001\u0146\u0001\u0146\u0001\u0146\u0001"+ + "\u0146\u0001\u0146\u0001\u0146\u0001\u0146\u0001\u0146\u0001\u0146\u0001"+ + "\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001\u0147\u0001"+ + "\u0147\u0001\u0147\u0001\u0147\u0001\u0148\u0001\u0148\u0001\u0148\u0001"+ + "\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001"+ + "\u0148\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001"+ + "\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001"+ + "\u0149\u0001\u0149\u0001\u014a\u0001\u014a\u0001\u014a\u0001\u014a\u0001"+ + "\u014a\u0001\u014a\u0001\u014a\u0001\u014b\u0001\u014b\u0001\u014b\u0001"+ + "\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014c\u0001"+ + "\u014c\u0001\u014c\u0001\u014c\u0001\u014d\u0001\u014d\u0001\u014d\u0001"+ + "\u014d\u0001\u014d\u0001\u014d\u0001\u014e\u0001\u014e\u0001\u014e\u0001"+ + "\u014e\u0001\u014e\u0001\u014f\u0001\u014f\u0001\u014f\u0001\u014f\u0001"+ + "\u014f\u0001\u014f\u0001\u014f\u0001\u0150\u0001\u0150\u0001\u0150\u0001"+ + "\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001\u0150\u0001"+ + "\u0151\u0001\u0151\u0001\u0151\u0001\u0151\u0001\u0151\u0001\u0151\u0001"+ + "\u0151\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001"+ + "\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001"+ + "\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001"+ + "\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001"+ + "\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0155\u0001\u0155\u0001"+ + "\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001"+ + "\u0155\u0001\u0155\u0001\u0155\u0001\u0156\u0001\u0156\u0001\u0156\u0001"+ + "\u0156\u0001\u0156\u0001\u0156\u0001\u0157\u0001\u0157\u0001\u0157\u0001"+ + "\u0157\u0001\u0157\u0001\u0157\u0001\u0157\u0001\u0158\u0001\u0158\u0001"+ + "\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001\u0158\u0001"+ + "\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u0159\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001\u015a\u0001"+ + "\u015a\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001\u015b\u0001"+ + "\u015b\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001"+ + "\u015c\u0001\u015c\u0001\u015d\u0001\u015d\u0001\u015d\u0001\u015d\u0001"+ + "\u015d\u0001\u015d\u0001\u015d\u0001\u015e\u0001\u015e\u0001\u015e\u0001"+ + "\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001"+ + "\u015e\u0001\u015e\u0001\u015f\u0001\u015f\u0001\u015f\u0001\u015f\u0001"+ + "\u015f\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001"+ + "\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0161\u0001\u0161\u0001"+ + "\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001"+ + "\u0161\u0001\u0161\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162\u0001"+ + "\u0162\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001"+ + "\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001"+ + "\u0163\u0001\u0164\u0001\u0164\u0001\u0164\u0001\u0164\u0001\u0164\u0001"+ + "\u0164\u0001\u0164\u0001\u0164\u0001\u0165\u0001\u0165\u0001\u0165\u0001"+ + "\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001\u0165\u0001"+ + "\u0166\u0001\u0166\u0001\u0166\u0001\u0166\u0001\u0166\u0001\u0166\u0001"+ + "\u0166\u0001\u0166\u0001\u0167\u0001\u0167\u0001\u0167\u0001\u0167\u0001"+ + "\u0167\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0001"+ + "\u0168\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001"+ + "\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u016a\u0001"+ + "\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001"+ + "\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016a\u0001\u016b\u0001"+ + "\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001"+ + "\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016b\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016d\u0001"+ + "\u016d\u0001\u016d\u0001\u016d\u0001\u016d\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001"+ + "\u016f\u0001\u0170\u0001\u0170\u0001\u0170\u0001\u0170\u0001\u0170\u0001"+ + "\u0170\u0001\u0170\u0001\u0171\u0001\u0171\u0001\u0171\u0001\u0171\u0001"+ + "\u0171\u0001\u0171\u0001\u0171\u0001\u0172\u0001\u0172\u0001\u0172\u0001"+ + "\u0172\u0001\u0172\u0001\u0172\u0001\u0173\u0001\u0173\u0001\u0173\u0001"+ + "\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001"+ + "\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001"+ + "\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0175\u0001\u0175\u0001"+ + "\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0175\u0001"+ + "\u0176\u0001\u0176\u0001\u0176\u0001\u0176\u0001\u0176\u0001\u0176\u0001"+ + "\u0176\u0001\u0176\u0001\u0177\u0001\u0177\u0001\u0177\u0001\u0177\u0001"+ + "\u0177\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001"+ + "\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0179\u0001\u0179\u0001"+ + "\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001"+ + "\u0179\u0001\u0179\u0001\u0179\u0001\u017a\u0001\u017a\u0001\u017a\u0001"+ + "\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017a\u0001\u017b\u0001"+ + "\u017b\u0001\u017b\u0001\u017b\u0001\u017b\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001"+ + "\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017f\u0001\u017f\u0001"+ + "\u017f\u0001\u017f\u0001\u017f\u0001\u0180\u0001\u0180\u0001\u0180\u0001"+ + "\u0180\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0181\u0001"+ + "\u0182\u0001\u0182\u0001\u0182\u0001\u0182\u0001\u0182\u0001\u0182\u0001"+ + "\u0182\u0001\u0182\u0001\u0183\u0001\u0183\u0001\u0183\u0001\u0183\u0001"+ + "\u0183\u0001\u0183\u0001\u0183\u0001\u0184\u0001\u0184\u0001\u0184\u0001"+ + "\u0184\u0001\u0185\u0001\u0185\u0001\u0185\u0001\u0185\u0001\u0185\u0001"+ + "\u0185\u0001\u0185\u0001\u0185\u0001\u0186\u0001\u0186\u0001\u0186\u0001"+ + "\u0186\u0001\u0186\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001"+ + "\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001\u0187\u0001"+ + "\u0188\u0001\u0188\u0001\u0188\u0001\u0188\u0001\u0188\u0001\u0188\u0001"+ + "\u0188\u0001\u0188\u0001\u0188\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001\u018a\u0001"+ + "\u018a\u0001\u018a\u0001\u018a\u0001\u018b\u0001\u018b\u0001\u018b\u0001"+ + "\u018b\u0001\u018b\u0001\u018b\u0001\u018b\u0001\u018c\u0001\u018c\u0001"+ + "\u018c\u0001\u018c\u0001\u018c\u0001\u018c\u0001\u018c\u0001\u018c\u0001"+ + "\u018d\u0001\u018d\u0001\u018d\u0001\u018d\u0001\u018d\u0001\u018d\u0001"+ + "\u018e\u0001\u018e\u0001\u018e\u0001\u018e\u0001\u018e\u0001\u018e\u0001"+ + "\u018e\u0001\u018e\u0001\u018e\u0001\u018f\u0001\u018f\u0001\u018f\u0001"+ + "\u018f\u0001\u018f\u0001\u018f\u0001\u0190\u0001\u0190\u0001\u0190\u0001"+ + "\u0190\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0191\u0001"+ + "\u0191\u0001\u0191\u0001\u0191\u0001\u0192\u0001\u0192\u0001\u0192\u0001"+ + "\u0192\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0192\u0001"+ + "\u0193\u0001\u0193\u0001\u0193\u0001\u0193\u0001\u0193\u0001\u0193\u0001"+ + "\u0194\u0001\u0194\u0001\u0194\u0001\u0194\u0001\u0194\u0001\u0194\u0001"+ + "\u0194\u0001\u0194\u0001\u0194\u0001\u0195\u0001\u0195\u0001\u0195\u0001"+ + "\u0195\u0001\u0195\u0001\u0195\u0001\u0196\u0001\u0196\u0001\u0196\u0001"+ + "\u0196\u0001\u0196\u0001\u0197\u0001\u0197\u0001\u0197\u0001\u0197\u0001"+ + "\u0197\u0001\u0197\u0001\u0197\u0001\u0198\u0001\u0198\u0001\u0198\u0001"+ + "\u0198\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0199\u0001"+ + "\u0199\u0001\u0199\u0001\u0199\u0001\u0199\u0001\u0199\u0001\u0199\u0001"+ + "\u0199\u0001\u019a\u0001\u019a\u0001\u019a\u0001\u019a\u0001\u019a\u0001"+ + "\u019a\u0001\u019a\u0001\u019a\u0001\u019a\u0001\u019b\u0001\u019b\u0001"+ + "\u019b\u0001\u019b\u0001\u019b\u0001\u019b\u0001\u019b\u0001\u019b\u0001"+ + "\u019b\u0001\u019b\u0001\u019c\u0001\u019c\u0001\u019c\u0001\u019c\u0001"+ + "\u019c\u0001\u019d\u0001\u019d\u0001\u019d\u0001\u019d\u0001\u019e\u0001"+ + "\u019e\u0001\u019e\u0001\u019e\u0001\u019e\u0001\u019e\u0001\u019f\u0001"+ + "\u019f\u0001\u019f\u0001\u019f\u0001\u019f\u0001\u019f\u0001\u019f\u0001"+ + "\u019f\u0001\u019f\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001"+ + "\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001"+ + "\u01a1\u0001\u01a1\u0001\u01a1\u0001\u01a1\u0001\u01a1\u0001\u01a2\u0001"+ + "\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001"+ + "\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a4\u0001\u01a4\u0001\u01a4\u0001"+ + "\u01a4\u0001\u01a4\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001"+ + "\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001"+ + "\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a7\u0001"+ + "\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001"+ + "\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001\u01a7\u0001"+ + "\u01a7\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001"+ + "\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001"+ + "\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001"+ + "\u01a9\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001"+ + "\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001"+ + "\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001\u01aa\u0001"+ + "\u01aa\u0001\u01aa\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001"+ + "\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001"+ + "\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001"+ + "\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001"+ + "\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001\u01ab\u0001"+ + "\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001"+ + "\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001"+ + "\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001"+ + "\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ac\u0001"+ + "\u01ac\u0001\u01ac\u0001\u01ac\u0001\u01ad\u0001\u01ad\u0001\u01ad\u0001"+ + "\u01ad\u0001\u01ad\u0001\u01ad\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001"+ + "\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001"+ + "\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01ae\u0001\u01af\u0001\u01af\u0001"+ + "\u01af\u0001\u01af\u0001\u01af\u0001\u01af\u0001\u01af\u0001\u01af\u0001"+ + "\u01af\u0001\u01af\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001"+ + "\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001\u01b0\u0001"+ + "\u01b0\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001"+ + "\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b1\u0001\u01b2\u0001"+ + "\u01b2\u0001\u01b2\u0001\u01b2\u0001\u01b2\u0001\u01b2\u0001\u01b2\u0001"+ + "\u01b2\u0001\u01b2\u0001\u01b2\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001"+ + "\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001"+ + "\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001"+ + "\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001\u01b5\u0001"+ + "\u01b5\u0001\u01b5\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001"+ + "\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b6\u0001"+ + "\u01b6\u0001\u01b6\u0001\u01b6\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001"+ + "\u01b7\u0001\u01b7\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001"+ + "\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b9\u0001\u01b9\u0001"+ + "\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01b9\u0001\u01ba\u0001"+ + "\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001"+ + "\u01bb\u0001\u01bb\u0001\u01bb\u0001\u01bb\u0001\u01bb\u0001\u01bb\u0001"+ + "\u01bb\u0001\u01bb\u0001\u01bb\u0001\u01bb\u0001\u01bb\u0001\u01bc\u0001"+ + "\u01bc\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0001"+ + "\u01bc\u0001\u01bc\u0001\u01bc\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001"+ + "\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01be\u0001\u01be\u0001"+ + "\u01be\u0001\u01be\u0001\u01be\u0001\u01be\u0001\u01be\u0001\u01bf\u0001"+ + "\u01bf\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001"+ + "\u01bf\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001"+ + "\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001"+ + "\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001"+ + "\u01c1\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001"+ + "\u01c2\u0001\u01c2\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001"+ + "\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c4\u0001\u01c4\u0001\u01c4\u0001"+ + "\u01c4\u0001\u01c4\u0001\u01c4\u0001\u01c4\u0001\u01c5\u0001\u01c5\u0001"+ + "\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001"+ + "\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c6\u0001\u01c6\u0001"+ + "\u01c6\u0001\u01c6\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0001"+ + "\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001\u01c8\u0001"+ + "\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001"+ + "\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001"+ + "\u01c9\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001"+ + "\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001"+ + "\u01ca\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0001\u01cc\u0001"+ + "\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001"+ + "\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001"+ + "\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001"+ + "\u01ce\u0001\u01ce\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001"+ + "\u01cf\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001\u01cf\u0001"+ + "\u01cf\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001"+ + "\u01d0\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0001"+ + "\u01d1\u0001\u01d1\u0001\u01d1\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001"+ + "\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001"+ + "\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d4\u0001\u01d4\u0001"+ + "\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001"+ + "\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001"+ + "\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d5\u0001\u01d6\u0001"+ + "\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d6\u0001\u01d6\u0001"+ + "\u01d6\u0001\u01d6\u0001\u01d7\u0001\u01d7\u0001\u01d7\u0001\u01d7\u0001"+ + "\u01d7\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0001"+ + "\u01d8\u0001\u01d8\u0001\u01d9\u0001\u01d9\u0001\u01d9\u0001\u01d9\u0001"+ + "\u01d9\u0001\u01da\u0001\u01da\u0001\u01da\u0001\u01da\u0001\u01da\u0001"+ + "\u01da\u0001\u01da\u0001\u01db\u0001\u01db\u0001\u01db\u0001\u01db\u0001"+ + "\u01db\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001"+ + "\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dd\u0001\u01dd\u0001"+ + "\u01dd\u0001\u01dd\u0001\u01dd\u0001\u01de\u0001\u01de\u0001\u01de\u0001"+ + "\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0001"+ + "\u01de\u0001\u01de\u0001\u01de\u0001\u01df\u0001\u01df\u0001\u01df\u0001"+ + "\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001\u01df\u0001"+ + "\u01df\u0001\u01df\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001"+ + "\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e0\u0001\u01e1\u0001"+ + "\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001"+ + "\u01e1\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001"+ + "\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001"+ + "\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001"+ + "\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e4\u0001"+ + "\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001"+ + "\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001\u01e5\u0001\u01e5\u0001"+ + "\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e6\u0001"+ + "\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001"+ + "\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e7\u0001"+ + "\u01e7\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001\u01e8\u0001"+ + "\u01e8\u0001\u01e8\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001"+ + "\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001\u01eb\u0001\u01eb\u0001"+ + "\u01eb\u0001\u01eb\u0001\u01eb\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001"+ + "\u01ec\u0001\u01ec\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001"+ + "\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ed\u0001\u01ee\u0001\u01ee\u0001"+ + "\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ef\u0001\u01ef\u0001"+ + "\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001\u01ef\u0001"+ + "\u01ef\u0001\u01ef\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0001"+ + "\u01f0\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001"+ + "\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001"+ + "\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001"+ + "\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001"+ + "\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001"+ + "\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f2\u0001"+ + "\u01f2\u0001\u01f2\u0001\u01f2\u0001\u01f3\u0001\u01f3\u0001\u01f3\u0001"+ + "\u01f3\u0001\u01f3\u0001\u01f3\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001"+ + "\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001"+ + "\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f4\u0001\u01f5\u0001\u01f5\u0001"+ + "\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0001"+ + "\u01f5\u0001\u01f5\u0001\u01f5\u0001\u01f6\u0001\u01f6\u0001\u01f6\u0001"+ + "\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001"+ + "\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001\u01f7\u0001"+ + "\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001\u01f8\u0001"+ + "\u01f8\u0001\u01f8\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001"+ + "\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001"+ + "\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001\u01fa\u0001"+ + "\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001\u01fb\u0001"+ + "\u01fb\u0001\u01fb\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001\u01fc\u0001"+ + "\u01fc\u0001\u01fc\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0001"+ + "\u01fd\u0001\u01fd\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001"+ + "\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01fe\u0001\u01ff\u0001\u01ff\u0001"+ + "\u01ff\u0001\u01ff\u0001\u01ff\u0001\u01ff\u0001\u01ff\u0001\u01ff\u0001"+ + "\u0200\u0001\u0200\u0001\u0200\u0001\u0200\u0001\u0200\u0001\u0200\u0001"+ + "\u0201\u0001\u0201\u0001\u0201\u0001\u0201\u0001\u0201\u0001\u0202\u0001"+ + "\u0202\u0001\u0202\u0001\u0202\u0001\u0202\u0001\u0202\u0001\u0202\u0001"+ + "\u0203\u0001\u0203\u0001\u0203\u0001\u0203\u0001\u0203\u0001\u0203\u0001"+ + "\u0204\u0001\u0204\u0001\u0204\u0001\u0204\u0001\u0204\u0001\u0204\u0001"+ + "\u0205\u0001\u0205\u0001\u0205\u0001\u0205\u0001\u0205\u0001\u0205\u0001"+ + "\u0205\u0001\u0205\u0001\u0205\u0001\u0206\u0001\u0206\u0001\u0206\u0001"+ + "\u0206\u0001\u0206\u0001\u0206\u0001\u0207\u0001\u0207\u0001\u0207\u0001"+ + "\u0207\u0001\u0208\u0001\u0208\u0001\u0208\u0001\u0208\u0001\u0208\u0001"+ + "\u0209\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u0209\u0001\u0209\u0001"+ + "\u0209\u0001\u020a\u0001\u020a\u0001\u020a\u0001\u020a\u0001\u020a\u0001"+ + "\u020a\u0001\u020a\u0001\u020a\u0001\u020b\u0001\u020b\u0001\u020b\u0001"+ + "\u020b\u0001\u020b\u0001\u020b\u0001\u020b\u0001\u020b\u0001\u020b\u0001"+ + "\u020b\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c\u0001"+ + "\u020c\u0001\u020c\u0001\u020d\u0001\u020d\u0001\u020d\u0001\u020d\u0001"+ + "\u020d\u0001\u020e\u0001\u020e\u0001\u020e\u0001\u020e\u0001\u020e\u0001"+ + "\u020f\u0001\u020f\u0001\u020f\u0001\u020f\u0001\u0210\u0001\u0210\u0001"+ + "\u0210\u0001\u0210\u0001\u0211\u0001\u0211\u0001\u0211\u0001\u0211\u0001"+ + "\u0211\u0001\u0212\u0001\u0212\u0001\u0212\u0001\u0212\u0001\u0212\u0001"+ + "\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001"+ + "\u0213\u0001\u0213\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0214\u0001"+ + "\u0214\u0001\u0214\u0001\u0214\u0001\u0214\u0001\u0215\u0001\u0215\u0001"+ + "\u0215\u0001\u0215\u0001\u0216\u0001\u0216\u0001\u0216\u0001\u0216\u0001"+ + "\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001"+ + "\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0218\u0001\u0218\u0001"+ + "\u0218\u0001\u0218\u0001\u0218\u0001\u0218\u0001\u0219\u0001\u0219\u0001"+ + "\u0219\u0001\u0219\u0001\u021a\u0001\u021a\u0001\u021a\u0001\u021a\u0001"+ + "\u021b\u0001\u021b\u0001\u021b\u0001\u021c\u0001\u021c\u0001\u021c\u0001"+ + "\u021c\u0001\u021c\u0001\u021c\u0001\u021d\u0001\u021d\u0001\u021d\u0001"+ + "\u021d\u0001\u021d\u0001\u021d\u0001\u021d\u0001\u021d\u0001\u021d\u0001"+ + "\u021d\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021f\u0001"+ + "\u021f\u0001\u021f\u0001\u0220\u0001\u0220\u0001\u0220\u0001\u0220\u0001"+ + "\u0220\u0001\u0220\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001"+ + "\u0221\u0001\u0221\u0001\u0221\u0001\u0221\u0001\u0222\u0001\u0222\u0001"+ + "\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0223\u0001\u0223\u0001"+ + "\u0223\u0001\u0223\u0001\u0223\u0001\u0223\u0001\u0224\u0001\u0224\u0001"+ + "\u0224\u0001\u0224\u0001\u0224\u0001\u0225\u0001\u0225\u0001\u0225\u0001"+ + "\u0225\u0001\u0225\u0001\u0226\u0001\u0226\u0001\u0226\u0001\u0226\u0001"+ + "\u0226\u0001\u0226\u0001\u0226\u0001\u0226\u0001\u0226\u0001\u0226\u0001"+ + "\u0226\u0001\u0227\u0001\u0227\u0001\u0227\u0001\u0227\u0001\u0227\u0001"+ + "\u0227\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001"+ + "\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001\u0228\u0001"+ + "\u0228\u0001\u0228\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229\u0001"+ + "\u0229\u0001\u0229\u0001\u0229\u0001\u022a\u0001\u022a\u0001\u022a\u0001"+ + "\u022a\u0001\u022a\u0001\u022a\u0001\u022a\u0001\u022a\u0001\u022b\u0001"+ + "\u022b\u0001\u022b\u0001\u022b\u0001\u022b\u0001\u022c\u0001\u022c\u0001"+ + "\u022c\u0001\u022c\u0001\u022c\u0001\u022c\u0001\u022d\u0001\u022d\u0001"+ + "\u022d\u0001\u022d\u0001\u022d\u0001\u022e\u0001\u022e\u0001\u022e\u0001"+ + "\u022e\u0001\u022e\u0001\u022e\u0001\u022f\u0001\u022f\u0001\u022f\u0001"+ + "\u022f\u0001\u022f\u0001\u0230\u0001\u0230\u0001\u0230\u0001\u0230\u0001"+ + "\u0230\u0001\u0230\u0001\u0231\u0001\u0231\u0001\u0231\u0001\u0231\u0001"+ + "\u0231\u0001\u0231\u0001\u0232\u0001\u0232\u0001\u0232\u0001\u0232\u0001"+ + "\u0232\u0001\u0232\u0001\u0232\u0001\u0233\u0001\u0233\u0001\u0233\u0001"+ + "\u0233\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234\u0001"+ + "\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0236\u0001\u0236\u0001"+ + "\u0236\u0001\u0236\u0001\u0236\u0001\u0237\u0001\u0237\u0001\u0237\u0001"+ + "\u0237\u0001\u0238\u0001\u0238\u0001\u0238\u0001\u0238\u0001\u0238\u0001"+ + "\u0239\u0001\u0239\u0001\u0239\u0001\u0239\u0001\u023a\u0001\u023a\u0001"+ + "\u023a\u0001\u023a\u0001\u023a\u0001\u023b\u0001\u023b\u0001\u023b\u0001"+ + "\u023b\u0001\u023b\u0001\u023c\u0001\u023c\u0001\u023c\u0001\u023c\u0001"+ + "\u023c\u0001\u023d\u0001\u023d\u0001\u023d\u0001\u023d\u0001\u023d\u0001"+ + "\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0001"+ + "\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001\u023f\u0001"+ + "\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001"+ + "\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001"+ + "\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0241\u0001\u0242\u0001"+ + "\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001"+ + "\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0244\u0001\u0244\u0001"+ + "\u0244\u0001\u0244\u0001\u0244\u0001\u0244\u0001\u0245\u0001\u0245\u0001"+ + "\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001"+ + "\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0245\u0001\u0246\u0001"+ + "\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0246\u0001\u0247\u0001"+ + "\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0247\u0001\u0248\u0001"+ + "\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0248\u0001\u0249\u0001"+ + "\u0249\u0001\u0249\u0001\u0249\u0001\u024a\u0001\u024a\u0001\u024a\u0001"+ + "\u024a\u0001\u024a\u0001\u024a\u0001\u024a\u0001\u024b\u0001\u024b\u0001"+ + "\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001"+ + "\u024b\u0001\u024b\u0001\u024c\u0001\u024c\u0001\u024c\u0001\u024c\u0001"+ + "\u024c\u0001\u024c\u0001\u024c\u0001\u024d\u0001\u024d\u0001\u024d\u0001"+ + "\u024d\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024d\u0001\u024e\u0001"+ + "\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001\u024e\u0001"+ + "\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u0250\u0001"+ + "\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0251\u0001"+ + "\u0251\u0001\u0251\u0001\u0251\u0001\u0252\u0001\u0252\u0001\u0252\u0001"+ + "\u0252\u0001\u0252\u0001\u0252\u0001\u0252\u0001\u0252\u0001\u0252\u0001"+ + "\u0252\u0001\u0252\u0001\u0252\u0001\u0253\u0001\u0253\u0001\u0253\u0001"+ + "\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001"+ + "\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001"+ + "\u0253\u0001\u0253\u0001\u0253\u0001\u0253\u0001\u0254\u0001\u0254\u0001"+ + "\u0254\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0254\u0001"+ + "\u0254\u0001\u0254\u0001\u0254\u0001\u0254\u0001\u0255\u0001\u0255\u0001"+ + "\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001"+ + "\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001\u0255\u0001"+ + "\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001"+ + "\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001\u0256\u0001"+ + "\u0256\u0001\u0256\u0001\u0256\u0001\u0257\u0001\u0257\u0001\u0257\u0001"+ + "\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001"+ + "\u0257\u0001\u0257\u0001\u0257\u0001\u0257\u0001\u0258\u0001\u0258\u0001"+ + "\u0258\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0258\u0001"+ + "\u0258\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0258\u0001\u0259\u0001"+ + "\u0259\u0001\u0259\u0001\u0259\u0001\u0259\u0001\u0259\u0001\u0259\u0001"+ + "\u0259\u0001\u0259\u0001\u0259\u0001\u0259\u0001\u0259\u0001\u025a\u0001"+ + "\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001"+ + "\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001\u025a\u0001"+ + "\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001"+ + "\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001"+ + "\u025b\u0001\u025b\u0001\u025b\u0001\u025c\u0001\u025c\u0001\u025c\u0001"+ + "\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001"+ + "\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001"+ + "\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001"+ + "\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001"+ + "\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001"+ + "\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025e\u0001\u025e\u0001"+ + "\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001"+ + "\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001"+ + "\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001\u025e\u0001"+ + "\u025e\u0001\u025e\u0001\u025f\u0001\u025f\u0001\u025f\u0001\u025f\u0001"+ + "\u025f\u0001\u025f\u0001\u025f\u0001\u025f\u0001\u025f\u0001\u025f\u0001"+ + "\u025f\u0001\u025f\u0001\u025f\u0001\u025f\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0261\u0001"+ + "\u0261\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0262\u0001\u0262\u0001"+ + "\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0263\u0001\u0263\u0001"+ + "\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001\u0263\u0001"+ + "\u0263\u0001\u0263\u0001\u0263\u0001\u0264\u0001\u0264\u0001\u0264\u0001"+ + "\u0264\u0001\u0264\u0001\u0264\u0001\u0264\u0001\u0264\u0001\u0264\u0001"+ + "\u0264\u0001\u0264\u0001\u0264\u0001\u0265\u0001\u0265\u0001\u0265\u0001"+ + "\u0265\u0001\u0265\u0001\u0265\u0001\u0265\u0001\u0265\u0001\u0265\u0001"+ + "\u0265\u0001\u0265\u0001\u0265\u0001\u0265\u0001\u0265\u0001\u0265\u0001"+ + "\u0265\u0001\u0266\u0001\u0266\u0001\u0266\u0001\u0266\u0001\u0266\u0001"+ + "\u0266\u0001\u0266\u0001\u0266\u0001\u0266\u0001\u0266\u0001\u0266\u0001"+ + "\u0266\u0001\u0266\u0001\u0266\u0001\u0266\u0001\u0266\u0001\u0267\u0001"+ + "\u0267\u0001\u0267\u0001\u0267\u0001\u0267\u0001\u0267\u0001\u0267\u0001"+ + "\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001"+ + "\u0268\u0001\u0269\u0001\u0269\u0001\u0269\u0001\u0269\u0001\u0269\u0001"+ + "\u0269\u0001\u0269\u0001\u0269\u0001\u0269\u0001\u026a\u0001\u026a\u0001"+ + "\u026a\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026b\u0001"+ + "\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001"+ + "\u026b\u0001\u026b\u0001\u026b\u0001\u026c\u0001\u026c\u0001\u026c\u0001"+ + "\u026c\u0001\u026c\u0001\u026c\u0001\u026c\u0001\u026d\u0001\u026d\u0001"+ + "\u026d\u0001\u026d\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001"+ + "\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001"+ + "\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001\u026e\u0001"+ + "\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001\u026f\u0001"+ + "\u026f\u0001\u026f\u0001\u026f\u0001\u0270\u0001\u0270\u0001\u0270\u0001"+ + "\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001"+ + "\u0270\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001"+ + "\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001\u0271\u0001"+ + "\u0272\u0001\u0272\u0001\u0272\u0001\u0272\u0001\u0272\u0001\u0272\u0001"+ + "\u0272\u0001\u0272\u0001\u0272\u0001\u0273\u0001\u0273\u0001\u0273\u0001"+ + "\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001"+ + "\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0274\u0001\u0274\u0001"+ + "\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001"+ + "\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001"+ + "\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001"+ + "\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001"+ + "\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0276\u0001"+ + "\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001"+ + "\u0276\u0001\u0276\u0001\u0276\u0001\u0277\u0001\u0277\u0001\u0277\u0001"+ + "\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001"+ + "\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0278\u0001"+ + "\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001\u0278\u0001"+ + "\u0278\u0001\u0278\u0001\u0278\u0001\u0279\u0001\u0279\u0001\u0279\u0001"+ + "\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001"+ + "\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279\u0001"+ + "\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001"+ + "\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001"+ + "\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027a\u0001\u027b\u0001"+ + "\u027b\u0001\u027b\u0001\u027b\u0001\u027c\u0001\u027c\u0001\u027c\u0001"+ + "\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001"+ + "\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001"+ + "\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027c\u0001\u027d\u0001"+ + "\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0001"+ + "\u027d\u0001\u027d\u0001\u027d\u0001\u027e\u0001\u027e\u0001\u027e\u0001"+ + "\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001"+ + "\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001"+ + "\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001"+ + "\u027e\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001"+ + "\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001"+ + "\u027f\u0001\u027f\u0001\u0280\u0001\u0280\u0001\u0280\u0001\u0280\u0001"+ + "\u0280\u0001\u0280\u0001\u0280\u0001\u0280\u0001\u0281\u0001\u0281\u0001"+ + "\u0281\u0001\u0281\u0001\u0281\u0001\u0281\u0001\u0281\u0001\u0281\u0001"+ + "\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001"+ + "\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0283\u0001\u0283\u0005"+ + "\u0283\u18d8\b\u0283\n\u0283\f\u0283\u18db\t\u0283\u0001\u0284\u0001\u0284"+ + "\u0001\u0284\u0001\u0284\u0001\u0284\u0001\u0284\u0003\u0284\u18e3\b\u0284"+ + "\u0001\u0285\u0001\u0285\u0003\u0285\u18e7\b\u0285\u0001\u0286\u0001\u0286"+ + "\u0003\u0286\u18eb\b\u0286\u0001\u0287\u0001\u0287\u0001\u0287\u0001\u0288"+ + "\u0001\u0288\u0001\u0288\u0001\u0288\u0005\u0288\u18f4\b\u0288\n\u0288"+ + "\f\u0288\u18f7\t\u0288\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u028a"+ + "\u0001\u028a\u0001\u028a\u0001\u028a\u0005\u028a\u1900\b\u028a\n\u028a"+ + "\f\u028a\u1903\t\u028a\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b"+ + "\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028d\u0001\u028d"+ + "\u0001\u028d\u0001\u028d\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e"+ "\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u0290\u0001\u0290\u0001\u0290"+ "\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290"+ - "\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290"+ - "\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290"+ - "\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0291\u0001\u0291"+ - "\u0001\u0291\u0001\u0291\u0001\u0291\u0001\u0291\u0001\u0292\u0001\u0292"+ - "\u0001\u0292\u0001\u0292\u0001\u0292\u0001\u0292\u0001\u0292\u0001\u0293"+ - "\u0001\u0293\u0001\u0293\u0001\u0293\u0001\u0293\u0001\u0293\u0001\u0294"+ - "\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294"+ - "\u0001\u0294\u0001\u0294\u0001\u0295\u0001\u0295\u0001\u0295\u0001\u0295"+ - "\u0001\u0295\u0001\u0295\u0001\u0295\u0001\u0295\u0001\u0295\u0001\u0295"+ - "\u0001\u0296\u0001\u0296\u0001\u0296\u0001\u0296\u0001\u0296\u0001\u0296"+ - "\u0001\u0297\u0001\u0297\u0001\u0297\u0001\u0297\u0001\u0297\u0001\u0297"+ - "\u0001\u0297\u0001\u0298\u0001\u0298\u0001\u0298\u0001\u0298\u0001\u0298"+ - "\u0001\u0298\u0001\u0298\u0001\u0298\u0001\u0299\u0001\u0299\u0001\u0299"+ - "\u0001\u0299\u0001\u0299\u0001\u0299\u0001\u0299\u0001\u0299\u0001\u0299"+ - "\u0001\u029a\u0001\u029a\u0001\u029a\u0001\u029a\u0001\u029a\u0001\u029a"+ - "\u0001\u029a\u0001\u029a\u0001\u029b\u0001\u029b\u0001\u029b\u0001\u029b"+ - "\u0001\u029b\u0001\u029b\u0001\u029b\u0001\u029b\u0001\u029b\u0001\u029c"+ - "\u0001\u029c\u0001\u029c\u0001\u029c\u0001\u029c\u0001\u029c\u0001\u029c"+ - "\u0001\u029c\u0001\u029c\u0001\u029d\u0001\u029d\u0001\u029d\u0001\u029d"+ - "\u0001\u029d\u0001\u029d\u0001\u029d\u0001\u029d\u0001\u029e\u0001\u029e"+ - "\u0001\u029e\u0001\u029e\u0001\u029e\u0001\u029e\u0001\u029e\u0001\u029e"+ - "\u0001\u029f\u0001\u029f\u0001\u029f\u0001\u029f\u0001\u029f\u0001\u02a0"+ - "\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a0"+ - "\u0001\u02a0\u0001\u02a0\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0001\u02a1"+ - "\u0001\u02a1\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2"+ - "\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a3\u0001\u02a3"+ - "\u0001\u02a3\u0001\u02a3\u0001\u02a3\u0001\u02a3\u0001\u02a4\u0001\u02a4"+ - "\u0001\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a4"+ - "\u0001\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a5"+ - "\u0001\u02a5\u0001\u02a5\u0001\u02a5\u0001\u02a5\u0001\u02a5\u0001\u02a5"+ - "\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001\u02a7"+ - "\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a7"+ - "\u0001\u02a8\u0001\u02a8\u0001\u02a8\u0001\u02a8\u0001\u02a8\u0001\u02a8"+ - "\u0001\u02a8\u0001\u02a8\u0001\u02a9\u0001\u02a9\u0001\u02a9\u0001\u02a9"+ - "\u0001\u02a9\u0001\u02aa\u0001\u02aa\u0001\u02aa\u0001\u02aa\u0001\u02aa"+ - "\u0001\u02aa\u0001\u02ab\u0001\u02ab\u0001\u02ab\u0001\u02ab\u0001\u02ab"+ - "\u0001\u02ac\u0001\u02ac\u0001\u02ac\u0001\u02ac\u0001\u02ac\u0001\u02ad"+ - "\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ae\u0001\u02ae\u0001\u02ae"+ - "\u0001\u02ae\u0001\u02ae\u0001\u02af\u0001\u02af\u0001\u02af\u0001\u02af"+ - "\u0001\u02af\u0001\u02af\u0001\u02af\u0001\u02af\u0001\u02af\u0001\u02af"+ - "\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0"+ - "\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0"+ - "\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1"+ - "\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b2"+ - "\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b2"+ - "\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b2"+ - "\u0001\u02b3\u0001\u02b3\u0001\u02b3\u0001\u02b3\u0001\u02b3\u0001\u02b3"+ - "\u0001\u02b3\u0001\u02b3\u0001\u02b4\u0001\u02b4\u0001\u02b4\u0001\u02b4"+ - "\u0001\u02b4\u0001\u02b4\u0001\u02b4\u0001\u02b4\u0001\u02b4\u0001\u02b4"+ - "\u0001\u02b5\u0001\u02b5\u0001\u02b5\u0001\u02b5\u0001\u02b5\u0001\u02b5"+ - "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ - "\u0001\u02b6\u0001\u02b6\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7"+ - "\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7"+ - "\u0001\u02b7\u0001\u02b7\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8"+ - "\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8"+ - "\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b8\u0001\u02b9\u0001\u02b9"+ - "\u0001\u02b9\u0001\u02b9\u0001\u02b9\u0001\u02b9\u0001\u02b9\u0001\u02b9"+ - "\u0001\u02b9\u0001\u02b9\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba"+ - "\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba\u0001\u02ba"+ - "\u0001\u02ba\u0001\u02ba\u0001\u02bb\u0001\u02bb\u0001\u02bb\u0001\u02bb"+ - "\u0001\u02bb\u0001\u02bb\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc"+ - "\u0001\u02bc\u0001\u02bc\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02bd"+ - "\u0001\u02bd\u0001\u02bd\u0001\u02bd\u0001\u02be\u0001\u02be\u0001\u02be"+ - "\u0001\u02be\u0001\u02be\u0001\u02be\u0001\u02be\u0001\u02be\u0001\u02be"+ - "\u0001\u02be\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf"+ - "\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf"+ - "\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02bf\u0001\u02c0"+ - "\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0"+ - "\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c1"+ - "\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1"+ - "\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0001\u02c2\u0001\u02c2"+ - "\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2"+ - "\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c2\u0001\u02c3"+ - "\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3\u0001\u02c3"+ - "\u0001\u02c3\u0001\u02c3\u0001\u02c4\u0001\u02c4\u0001\u02c4\u0001\u02c4"+ - "\u0001\u02c4\u0001\u02c4\u0001\u02c4\u0001\u02c5\u0001\u02c5\u0001\u02c5"+ - "\u0001\u02c5\u0001\u02c5\u0001\u02c5\u0001\u02c5\u0001\u02c5\u0001\u02c5"+ - "\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6"+ - "\u0001\u02c6\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c7"+ - "\u0001\u02c7\u0001\u02c7\u0001\u02c7\u0001\u02c8\u0001\u02c8\u0001\u02c8"+ - "\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c8\u0001\u02c8"+ - "\u0001\u02c8\u0001\u02c8\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9"+ - "\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9"+ - "\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9"+ - "\u0001\u02c9\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02ca"+ - "\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0001\u02cb"+ - "\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001\u02cb"+ - "\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cc"+ - "\u0001\u02cc\u0001\u02cc\u0001\u02cc\u0001\u02cd\u0001\u02cd\u0001\u02cd"+ - "\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd"+ - "\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02cd\u0001\u02ce\u0001\u02ce"+ - "\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02cf\u0001\u02cf\u0001\u02cf"+ - "\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf\u0001\u02cf"+ - "\u0001\u02cf\u0001\u02cf\u0001\u02d0\u0001\u02d0\u0001\u02d0\u0001\u02d0"+ - "\u0001\u02d0\u0001\u02d0\u0001\u02d0\u0001\u02d1\u0001\u02d1\u0001\u02d1"+ - "\u0001\u02d1\u0001\u02d1\u0001\u02d1\u0001\u02d1\u0001\u02d1\u0001\u02d1"+ - "\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d3\u0001\u02d3\u0001\u02d3"+ - "\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d4\u0001\u02d4"+ - "\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d4"+ - "\u0001\u02d4\u0001\u02d4\u0001\u02d4\u0001\u02d5\u0001\u02d5\u0001\u02d5"+ - "\u0001\u02d5\u0001\u02d5\u0001\u02d5\u0001\u02d5\u0001\u02d5\u0001\u02d5"+ - "\u0001\u02d6\u0001\u02d6\u0001\u02d6\u0001\u02d6\u0001\u02d6\u0001\u02d6"+ - "\u0001\u02d6\u0001\u02d6\u0001\u02d6\u0001\u02d7\u0001\u02d7\u0001\u02d7"+ - "\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d8"+ - "\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8"+ - "\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8"+ - "\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d9"+ - "\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9"+ - "\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02da"+ - "\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02da\u0001\u02db"+ - "\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db"+ - "\u0001\u02db\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc"+ - "\u0001\u02dc\u0001\u02dc\u0001\u02dd\u0001\u02dd\u0001\u02dd\u0001\u02dd"+ - "\u0001\u02dd\u0001\u02dd\u0001\u02de\u0001\u02de\u0001\u02de\u0001\u02de"+ - "\u0001\u02de\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df\u0001\u02df"+ - "\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0\u0001\u02e0"+ - "\u0001\u02e0\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e2"+ - "\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e3\u0001\u02e3"+ - "\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3"+ - "\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e4"+ - "\u0001\u02e4\u0001\u02e4\u0001\u02e4\u0001\u02e4\u0001\u02e4\u0001\u02e4"+ - "\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5"+ - "\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0001\u02e5"+ - "\u0001\u02e5\u0001\u02e6\u0001\u02e6\u0001\u02e6\u0001\u02e6\u0001\u02e6"+ - "\u0001\u02e6\u0001\u02e6\u0001\u02e6\u0001\u02e7\u0001\u02e7\u0001\u02e7"+ - "\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7\u0001\u02e7"+ - "\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8"+ - "\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e8\u0001\u02e9"+ - "\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9"+ - "\u0001\u02e9\u0001\u02ea\u0001\u02ea\u0001\u02ea\u0001\u02ea\u0001\u02ea"+ - "\u0001\u02ea\u0001\u02ea\u0001\u02eb\u0001\u02eb\u0001\u02eb\u0001\u02eb"+ - "\u0001\u02eb\u0001\u02eb\u0001\u02eb\u0001\u02ec\u0001\u02ec\u0001\u02ec"+ - "\u0001\u02ec\u0001\u02ec\u0001\u02ec\u0001\u02ec\u0001\u02ed\u0001\u02ed"+ - "\u0001\u02ed\u0001\u02ed\u0001\u02ed\u0001\u02ed\u0001\u02ed\u0001\u02ee"+ - "\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ef"+ - "\u0001\u02ef\u0001\u02ef\u0001\u02ef\u0001\u02ef\u0001\u02ef\u0001\u02ef"+ - "\u0001\u02ef\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f0"+ - "\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f1"+ - "\u0001\u02f1\u0001\u02f1\u0001\u02f1\u0001\u02f1\u0001\u02f1\u0001\u02f1"+ - "\u0001\u02f1\u0001\u02f1\u0001\u02f1\u0001\u02f1\u0001\u02f1\u0001\u02f2"+ - "\u0001\u02f2\u0001\u02f2\u0001\u02f2\u0001\u02f2\u0001\u02f3\u0001\u02f3"+ - "\u0001\u02f3\u0001\u02f3\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4"+ - "\u0001\u02f4\u0001\u02f4\u0001\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f5"+ - "\u0001\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f5"+ - "\u0001\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f5"+ - "\u0001\u02f5\u0001\u02f5\u0001\u02f6\u0001\u02f6\u0001\u02f6\u0001\u02f6"+ - "\u0001\u02f6\u0001\u02f7\u0001\u02f7\u0001\u02f7\u0001\u02f7\u0001\u02f7"+ - "\u0001\u02f7\u0001\u02f7\u0001\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f8"+ - "\u0001\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f9\u0001\u02f9\u0001\u02f9"+ - "\u0001\u02f9\u0001\u02f9\u0001\u02f9\u0001\u02f9\u0001\u02fa\u0001\u02fa"+ - "\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fb\u0001\u02fb\u0001\u02fb"+ - "\u0001\u02fb\u0001\u02fb\u0001\u02fc\u0001\u02fc\u0001\u02fc\u0001\u02fc"+ - "\u0001\u02fc\u0001\u02fd\u0001\u02fd\u0001\u02fd\u0001\u02fd\u0001\u02fd"+ - "\u0001\u02fe\u0001\u02fe\u0001\u02fe\u0001\u02fe\u0001\u02fe\u0001\u02ff"+ - "\u0001\u02ff\u0001\u02ff\u0001\u02ff\u0001\u02ff\u0001\u02ff\u0001\u0300"+ - "\u0001\u0300\u0001\u0300\u0001\u0300\u0001\u0300\u0001\u0301\u0001\u0301"+ - "\u0001\u0301\u0001\u0301\u0001\u0301\u0001\u0302\u0001\u0302\u0001\u0302"+ - "\u0001\u0302\u0001\u0302\u0001\u0302\u0001\u0302\u0001\u0302\u0001\u0303"+ - "\u0001\u0303\u0001\u0303\u0001\u0303\u0001\u0303\u0001\u0303\u0001\u0303"+ - "\u0001\u0303\u0001\u0303\u0001\u0304\u0001\u0304\u0001\u0304\u0001\u0304"+ - "\u0001\u0304\u0001\u0304\u0001\u0305\u0001\u0305\u0001\u0305\u0001\u0305"+ - "\u0001\u0305\u0001\u0305\u0001\u0305\u0001\u0306\u0001\u0306\u0001\u0306"+ - "\u0001\u0306\u0001\u0306\u0001\u0306\u0001\u0307\u0001\u0307\u0001\u0307"+ - "\u0001\u0307\u0001\u0307\u0001\u0307\u0001\u0307\u0001\u0307\u0001\u0308"+ - "\u0001\u0308\u0001\u0308\u0001\u0308\u0001\u0308\u0001\u0308\u0001\u0308"+ - "\u0001\u0308\u0001\u0309\u0001\u0309\u0001\u0309\u0001\u0309\u0001\u0309"+ - "\u0001\u0309\u0001\u0309\u0001\u030a\u0001\u030a\u0001\u030a\u0001\u030a"+ - "\u0001\u030a\u0001\u030a\u0001\u030a\u0001\u030a\u0001\u030b\u0001\u030b"+ - "\u0001\u030b\u0001\u030b\u0001\u030b\u0001\u030b\u0001\u030b\u0001\u030b"+ - "\u0001\u030c\u0001\u030c\u0001\u030c\u0001\u030c\u0001\u030c\u0001\u030c"+ - "\u0001\u030c\u0001\u030c\u0001\u030d\u0001\u030d\u0001\u030d\u0001\u030d"+ - "\u0001\u030d\u0001\u030d\u0001\u030d\u0001\u030d\u0001\u030d\u0001\u030d"+ - "\u0001\u030d\u0001\u030d\u0001\u030e\u0001\u030e\u0001\u030e\u0001\u030e"+ - "\u0001\u030e\u0001\u030e\u0001\u030e\u0001\u030f\u0001\u030f\u0001\u030f"+ - "\u0001\u030f\u0001\u030f\u0001\u0310\u0001\u0310\u0001\u0310\u0001\u0310"+ - "\u0001\u0310\u0001\u0310\u0001\u0310\u0001\u0310\u0001\u0310\u0001\u0310"+ - "\u0001\u0310\u0001\u0310\u0001\u0311\u0001\u0311\u0001\u0311\u0001\u0311"+ - "\u0001\u0311\u0001\u0311\u0001\u0311\u0001\u0312\u0001\u0312\u0001\u0312"+ - "\u0001\u0312\u0001\u0312\u0001\u0312\u0001\u0312\u0001\u0312\u0001\u0313"+ - "\u0001\u0313\u0001\u0313\u0001\u0313\u0001\u0313\u0001\u0313\u0001\u0313"+ - "\u0001\u0313\u0001\u0313\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0314"+ - "\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0314"+ - "\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0314\u0001\u0315\u0001\u0315"+ - "\u0001\u0315\u0001\u0315\u0001\u0315\u0001\u0316\u0001\u0316\u0001\u0316"+ - "\u0001\u0316\u0001\u0316\u0001\u0316\u0001\u0316\u0001\u0317\u0001\u0317"+ - "\u0001\u0317\u0001\u0317\u0001\u0318\u0001\u0318\u0001\u0319\u0001\u0319"+ - "\u0001\u031a\u0001\u031a\u0001\u031a\u0001\u031b\u0001\u031b\u0001\u031c"+ - "\u0001\u031c\u0001\u031c\u0001\u031d\u0001\u031d\u0001\u031e\u0001\u031e"+ - "\u0001\u031f\u0001\u031f\u0001\u0320\u0001\u0320\u0001\u0321\u0001\u0321"+ - "\u0001\u0322\u0001\u0322\u0001\u0322\u0005\u0322\u2109\b\u0322\n\u0322"+ - "\f\u0322\u210c\t\u0322\u0001\u0322\u0001\u0322\u0001\u0323\u0001\u0323"+ - "\u0001\u0323\u0001\u0324\u0003\u0324\u2114\b\u0324\u0001\u0324\u0004\u0324"+ - "\u2117\b\u0324\u000b\u0324\f\u0324\u2118\u0001\u0324\u0001\u0324\u0004"+ - "\u0324\u211d\b\u0324\u000b\u0324\f\u0324\u211e\u0001\u0324\u0001\u0324"+ - "\u0005\u0324\u2123\b\u0324\n\u0324\f\u0324\u2126\t\u0324\u0001\u0324\u0004"+ - "\u0324\u2129\b\u0324\u000b\u0324\f\u0324\u212a\u0003\u0324\u212d\b\u0324"+ - "\u0001\u0325\u0003\u0325\u2130\b\u0325\u0001\u0325\u0004\u0325\u2133\b"+ - "\u0325\u000b\u0325\f\u0325\u2134\u0001\u0325\u0001\u0325\u0004\u0325\u2139"+ - "\b\u0325\u000b\u0325\f\u0325\u213a\u0003\u0325\u213d\b\u0325\u0001\u0326"+ - "\u0001\u0326\u0001\u0326\u0001\u0327\u0001\u0327\u0001\u0328\u0001\u0328"+ - "\u0001\u0329\u0001\u0329\u0001\u032a\u0001\u032a\u0005\u032a\u214a\b\u032a"+ - "\n\u032a\f\u032a\u214d\t\u032a\u0001\u032b\u0001\u032b\u0004\u032b\u2151"+ - "\b\u032b\u000b\u032b\f\u032b\u2152\u0001\u032c\u0001\u032c\u0005\u032c"+ - "\u2157\b\u032c\n\u032c\f\u032c\u215a\t\u032c\u0001\u032d\u0001\u032d\u0001"+ - "\u032e\u0001\u032e\u0001\u032e\u0001\u032f\u0001\u032f\u0001\u032f\u0001"+ - "\u0330\u0001\u0330\u0001\u0330\u0001\u0331\u0001\u0331\u0001\u0331\u0001"+ - "\u0332\u0001\u0332\u0001\u0333\u0001\u0333\u0001\u0334\u0001\u0334\u0001"+ - "\u0334\u0001\u0335\u0001\u0335\u0001\u0335\u0001\u0336\u0001\u0336\u0001"+ - "\u0337\u0001\u0337\u0001\u0338\u0001\u0338\u0001\u0338\u0001\u0339\u0001"+ - "\u0339\u0001\u033a\u0001\u033a\u0001\u033a\u0001\u033b\u0001\u033b\u0001"+ - "\u033b\u0001\u033c\u0001\u033c\u0001\u033d\u0001\u033d\u0001\u033d\u0001"+ - "\u033e\u0001\u033e\u0001\u033e\u0001\u033f\u0001\u033f\u0001\u033f\u0001"+ - "\u033f\u0001\u0340\u0001\u0340\u0001\u0340\u0001\u0341\u0001\u0341\u0001"+ - "\u0341\u0001\u0342\u0001\u0342\u0001\u0342\u0001\u0342\u0001\u0343\u0001"+ - "\u0343\u0001\u0343\u0001\u0343\u0001\u0344\u0001\u0344\u0001\u0345\u0001"+ - "\u0345\u0001\u0345\u0001\u0346\u0001\u0346\u0001\u0346\u0001\u0347\u0001"+ - "\u0347\u0001\u0347\u0001\u0348\u0001\u0348\u0001\u0348\u0001\u0349\u0001"+ - "\u0349\u0001\u0349\u0001\u0349\u0001\u034a\u0001\u034a\u0001\u034a\u0001"+ - "\u034b\u0001\u034b\u0001\u034b\u0001\u034b\u0001\u034c\u0001\u034c\u0001"+ - "\u034c\u0001\u034c\u0001\u034d\u0001\u034d\u0001\u034e\u0001\u034e\u0001"+ - "\u034f\u0001\u034f\u0001\u0350\u0001\u0350\u0001\u0350\u0001\u0351\u0001"+ - "\u0351\u0001\u0351\u0001\u0351\u0001\u0352\u0001\u0352\u0001\u0352\u0001"+ - "\u0353\u0001\u0353\u0001\u0354\u0001\u0354\u0001\u0355\u0001\u0355\u0001"+ - "\u0355\u0001\u0356\u0001\u0356\u0001\u0356\u0001\u0357\u0001\u0357\u0001"+ - "\u0357\u0001\u0358\u0001\u0358\u0001\u0358\u0001\u0359\u0001\u0359\u0001"+ - "\u035a\u0001\u035a\u0001\u035b\u0001\u035b\u0001\u035b\u0001\u035c\u0001"+ - "\u035c\u0001\u035c\u0001\u035c\u0001\u035c\u0001\u035d\u0001\u035d\u0001"+ - "\u035d\u0001\u035d\u0001\u035e\u0001\u035e\u0001\u035e\u0001\u035e\u0001"+ - "\u035e\u0001\u035f\u0001\u035f\u0001\u035f\u0001\u035f\u0001\u0360\u0001"+ - "\u0360\u0001\u0360\u0001\u0361\u0001\u0361\u0001\u0361\u0001\u0362\u0001"+ - "\u0362\u0001\u0363\u0001\u0363\u0001\u0363\u0001\u0363\u0001\u0363\u0001"+ - "\u0363\u0001\u0364\u0005\u0364\u2202\b\u0364\n\u0364\f\u0364\u2205\t\u0364"+ - "\u0003\u06d8\u06e6\u2203\u0000\u0365\u0001\u0001\u0003\u0002\u0005\u0003"+ - "\u0007\u0000\t\u0000\u000b\u0000\r\u0000\u000f\u0000\u0011\u0000\u0013"+ - "\u0000\u0015\u0000\u0017\u0000\u0019\u0000\u001b\u0000\u001d\u0000\u001f"+ - "\u0000!\u0000#\u0000%\u0000\'\u0000)\u0000+\u0000-\u0000/\u00001\u0000"+ - "3\u00005\u00007\u00009\u0000;\u0000=\u0000?\u0000A\u0000C\u0000E\u0004"+ - "G\u0005I\u0006K\u0007M\bO\tQ\nS\u000bU\fW\rY\u000e[\u000f]\u0010_\u0011"+ - "a\u0012c\u0013e\u0014g\u0015i\u0016k\u0017m\u0018o\u0019q\u001as\u001b"+ - "u\u001cw\u001dy\u001e{\u001f} \u007f!\u0081\"\u0083#\u0085$\u0087%\u0089"+ - "&\u008b\'\u008d(\u008f)\u0091*\u0093+\u0095,\u0097-\u0099.\u009b/\u009d"+ - "0\u009f1\u00a12\u00a33\u00a54\u00a75\u00a96\u00ab7\u00ad8\u00af9\u00b1"+ - ":\u00b3;\u00b5<\u00b7=\u00b9>\u00bb?\u00bd@\u00bfA\u00c1B\u00c3C\u00c5"+ - "D\u00c7E\u00c9F\u00cbG\u00cdH\u00cfI\u00d1J\u00d3K\u00d5L\u00d7M\u00d9"+ - "N\u00dbO\u00ddP\u00dfQ\u00e1R\u00e3S\u00e5T\u00e7U\u00e9V\u00ebW\u00ed"+ - "X\u00efY\u00f1Z\u00f3[\u00f5\\\u00f7]\u00f9^\u00fb_\u00fd`\u00ffa\u0101"+ - "b\u0103c\u0105d\u0107e\u0109f\u010bg\u010dh\u010fi\u0111j\u0113k\u0115"+ - "l\u0117m\u0119n\u011bo\u011dp\u011fq\u0121r\u0123s\u0125t\u0127u\u0129"+ - "v\u012bw\u012dx\u012fy\u0131z\u0133{\u0135|\u0137}\u0139~\u013b\u007f"+ - "\u013d\u0080\u013f\u0081\u0141\u0082\u0143\u0083\u0145\u0084\u0147\u0085"+ - "\u0149\u0086\u014b\u0087\u014d\u0088\u014f\u0089\u0151\u008a\u0153\u008b"+ - "\u0155\u008c\u0157\u008d\u0159\u008e\u015b\u008f\u015d\u0090\u015f\u0091"+ - "\u0161\u0092\u0163\u0093\u0165\u0094\u0167\u0095\u0169\u0096\u016b\u0097"+ - "\u016d\u0098\u016f\u0099\u0171\u009a\u0173\u009b\u0175\u009c\u0177\u009d"+ - "\u0179\u009e\u017b\u009f\u017d\u00a0\u017f\u00a1\u0181\u00a2\u0183\u00a3"+ - "\u0185\u00a4\u0187\u00a5\u0189\u00a6\u018b\u00a7\u018d\u00a8\u018f\u00a9"+ - "\u0191\u00aa\u0193\u00ab\u0195\u00ac\u0197\u00ad\u0199\u00ae\u019b\u00af"+ - "\u019d\u00b0\u019f\u00b1\u01a1\u00b2\u01a3\u00b3\u01a5\u00b4\u01a7\u00b5"+ - "\u01a9\u00b6\u01ab\u00b7\u01ad\u00b8\u01af\u00b9\u01b1\u00ba\u01b3\u00bb"+ - "\u01b5\u00bc\u01b7\u00bd\u01b9\u00be\u01bb\u00bf\u01bd\u00c0\u01bf\u00c1"+ - "\u01c1\u00c2\u01c3\u00c3\u01c5\u00c4\u01c7\u00c5\u01c9\u00c6\u01cb\u00c7"+ - "\u01cd\u00c8\u01cf\u00c9\u01d1\u00ca\u01d3\u00cb\u01d5\u00cc\u01d7\u00cd"+ - "\u01d9\u00ce\u01db\u00cf\u01dd\u00d0\u01df\u00d1\u01e1\u00d2\u01e3\u00d3"+ - "\u01e5\u00d4\u01e7\u00d5\u01e9\u00d6\u01eb\u00d7\u01ed\u00d8\u01ef\u00d9"+ - "\u01f1\u00da\u01f3\u00db\u01f5\u00dc\u01f7\u00dd\u01f9\u00de\u01fb\u00df"+ - "\u01fd\u00e0\u01ff\u00e1\u0201\u00e2\u0203\u00e3\u0205\u00e4\u0207\u00e5"+ - "\u0209\u00e6\u020b\u00e7\u020d\u00e8\u020f\u00e9\u0211\u00ea\u0213\u00eb"+ - "\u0215\u00ec\u0217\u00ed\u0219\u00ee\u021b\u00ef\u021d\u00f0\u021f\u00f1"+ - "\u0221\u00f2\u0223\u00f3\u0225\u00f4\u0227\u00f5\u0229\u00f6\u022b\u00f7"+ - "\u022d\u00f8\u022f\u00f9\u0231\u00fa\u0233\u00fb\u0235\u00fc\u0237\u00fd"+ - "\u0239\u00fe\u023b\u00ff\u023d\u0100\u023f\u0101\u0241\u0102\u0243\u0103"+ - "\u0245\u0104\u0247\u0105\u0249\u0106\u024b\u0107\u024d\u0108\u024f\u0109"+ - "\u0251\u010a\u0253\u010b\u0255\u010c\u0257\u010d\u0259\u010e\u025b\u010f"+ - "\u025d\u0110\u025f\u0111\u0261\u0112\u0263\u0113\u0265\u0114\u0267\u0115"+ - "\u0269\u0116\u026b\u0117\u026d\u0118\u026f\u0119\u0271\u011a\u0273\u011b"+ - "\u0275\u011c\u0277\u011d\u0279\u011e\u027b\u011f\u027d\u0120\u027f\u0121"+ - "\u0281\u0122\u0283\u0123\u0285\u0124\u0287\u0125\u0289\u0126\u028b\u0127"+ - "\u028d\u0128\u028f\u0129\u0291\u012a\u0293\u012b\u0295\u012c\u0297\u012d"+ - "\u0299\u012e\u029b\u012f\u029d\u0130\u029f\u0131\u02a1\u0132\u02a3\u0133"+ - "\u02a5\u0134\u02a7\u0135\u02a9\u0136\u02ab\u0137\u02ad\u0138\u02af\u0139"+ - "\u02b1\u013a\u02b3\u013b\u02b5\u013c\u02b7\u013d\u02b9\u013e\u02bb\u013f"+ - "\u02bd\u0140\u02bf\u0141\u02c1\u0142\u02c3\u0143\u02c5\u0144\u02c7\u0145"+ - "\u02c9\u0146\u02cb\u0147\u02cd\u0148\u02cf\u0149\u02d1\u014a\u02d3\u014b"+ - "\u02d5\u014c\u02d7\u014d\u02d9\u014e\u02db\u014f\u02dd\u0150\u02df\u0151"+ - "\u02e1\u0152\u02e3\u0153\u02e5\u0154\u02e7\u0155\u02e9\u0156\u02eb\u0157"+ - "\u02ed\u0158\u02ef\u0159\u02f1\u015a\u02f3\u015b\u02f5\u015c\u02f7\u015d"+ - "\u02f9\u015e\u02fb\u015f\u02fd\u0160\u02ff\u0161\u0301\u0162\u0303\u0163"+ - "\u0305\u0164\u0307\u0165\u0309\u0166\u030b\u0167\u030d\u0168\u030f\u0169"+ - "\u0311\u016a\u0313\u016b\u0315\u016c\u0317\u016d\u0319\u016e\u031b\u016f"+ - "\u031d\u0170\u031f\u0171\u0321\u0172\u0323\u0173\u0325\u0174\u0327\u0175"+ - "\u0329\u0176\u032b\u0177\u032d\u0178\u032f\u0179\u0331\u017a\u0333\u017b"+ - "\u0335\u017c\u0337\u017d\u0339\u017e\u033b\u017f\u033d\u0180\u033f\u0181"+ - "\u0341\u0182\u0343\u0183\u0345\u0184\u0347\u0185\u0349\u0186\u034b\u0187"+ - "\u034d\u0188\u034f\u0189\u0351\u018a\u0353\u018b\u0355\u018c\u0357\u018d"+ - "\u0359\u018e\u035b\u018f\u035d\u0190\u035f\u0191\u0361\u0192\u0363\u0193"+ - "\u0365\u0194\u0367\u0195\u0369\u0196\u036b\u0197\u036d\u0198\u036f\u0199"+ - "\u0371\u019a\u0373\u019b\u0375\u019c\u0377\u019d\u0379\u019e\u037b\u019f"+ - "\u037d\u01a0\u037f\u01a1\u0381\u01a2\u0383\u01a3\u0385\u01a4\u0387\u01a5"+ - "\u0389\u01a6\u038b\u01a7\u038d\u01a8\u038f\u01a9\u0391\u01aa\u0393\u01ab"+ - "\u0395\u01ac\u0397\u01ad\u0399\u01ae\u039b\u01af\u039d\u01b0\u039f\u01b1"+ - "\u03a1\u01b2\u03a3\u01b3\u03a5\u01b4\u03a7\u01b5\u03a9\u01b6\u03ab\u01b7"+ - "\u03ad\u01b8\u03af\u01b9\u03b1\u01ba\u03b3\u01bb\u03b5\u01bc\u03b7\u01bd"+ - "\u03b9\u01be\u03bb\u01bf\u03bd\u01c0\u03bf\u01c1\u03c1\u01c2\u03c3\u01c3"+ - "\u03c5\u01c4\u03c7\u01c5\u03c9\u01c6\u03cb\u01c7\u03cd\u01c8\u03cf\u01c9"+ - "\u03d1\u01ca\u03d3\u01cb\u03d5\u01cc\u03d7\u01cd\u03d9\u01ce\u03db\u01cf"+ - "\u03dd\u01d0\u03df\u01d1\u03e1\u01d2\u03e3\u01d3\u03e5\u01d4\u03e7\u01d5"+ - "\u03e9\u01d6\u03eb\u01d7\u03ed\u01d8\u03ef\u01d9\u03f1\u01da\u03f3\u01db"+ - "\u03f5\u01dc\u03f7\u01dd\u03f9\u01de\u03fb\u01df\u03fd\u01e0\u03ff\u01e1"+ - "\u0401\u01e2\u0403\u01e3\u0405\u01e4\u0407\u01e5\u0409\u01e6\u040b\u01e7"+ - "\u040d\u01e8\u040f\u01e9\u0411\u01ea\u0413\u01eb\u0415\u01ec\u0417\u01ed"+ - "\u0419\u01ee\u041b\u01ef\u041d\u01f0\u041f\u01f1\u0421\u01f2\u0423\u01f3"+ - "\u0425\u01f4\u0427\u01f5\u0429\u01f6\u042b\u01f7\u042d\u01f8\u042f\u01f9"+ - "\u0431\u01fa\u0433\u01fb\u0435\u01fc\u0437\u01fd\u0439\u01fe\u043b\u01ff"+ - "\u043d\u0200\u043f\u0201\u0441\u0202\u0443\u0203\u0445\u0204\u0447\u0205"+ - "\u0449\u0206\u044b\u0207\u044d\u0208\u044f\u0209\u0451\u020a\u0453\u020b"+ - "\u0455\u020c\u0457\u020d\u0459\u020e\u045b\u020f\u045d\u0210\u045f\u0211"+ - "\u0461\u0212\u0463\u0213\u0465\u0214\u0467\u0215\u0469\u0216\u046b\u0217"+ - "\u046d\u0218\u046f\u0219\u0471\u021a\u0473\u021b\u0475\u021c\u0477\u021d"+ - "\u0479\u021e\u047b\u021f\u047d\u0220\u047f\u0221\u0481\u0222\u0483\u0223"+ - "\u0485\u0224\u0487\u0225\u0489\u0226\u048b\u0227\u048d\u0228\u048f\u0229"+ - "\u0491\u022a\u0493\u022b\u0495\u022c\u0497\u022d\u0499\u022e\u049b\u022f"+ - "\u049d\u0230\u049f\u0231\u04a1\u0232\u04a3\u0233\u04a5\u0234\u04a7\u0235"+ - "\u04a9\u0236\u04ab\u0237\u04ad\u0238\u04af\u0239\u04b1\u023a\u04b3\u023b"+ - "\u04b5\u023c\u04b7\u023d\u04b9\u023e\u04bb\u023f\u04bd\u0240\u04bf\u0241"+ - "\u04c1\u0242\u04c3\u0243\u04c5\u0244\u04c7\u0245\u04c9\u0246\u04cb\u0247"+ - "\u04cd\u0248\u04cf\u0249\u04d1\u024a\u04d3\u024b\u04d5\u024c\u04d7\u024d"+ - "\u04d9\u024e\u04db\u024f\u04dd\u0250\u04df\u0251\u04e1\u0252\u04e3\u0253"+ - "\u04e5\u0254\u04e7\u0255\u04e9\u0256\u04eb\u0257\u04ed\u0258\u04ef\u0259"+ - "\u04f1\u025a\u04f3\u025b\u04f5\u025c\u04f7\u025d\u04f9\u025e\u04fb\u025f"+ - "\u04fd\u0260\u04ff\u0261\u0501\u0262\u0503\u0263\u0505\u0264\u0507\u0265"+ - "\u0509\u0266\u050b\u0267\u050d\u0268\u050f\u0269\u0511\u026a\u0513\u026b"+ - "\u0515\u026c\u0517\u026d\u0519\u026e\u051b\u026f\u051d\u0270\u051f\u0271"+ - "\u0521\u0272\u0523\u0273\u0525\u0274\u0527\u0275\u0529\u0276\u052b\u0277"+ - "\u052d\u0278\u052f\u0279\u0531\u027a\u0533\u027b\u0535\u027c\u0537\u027d"+ - "\u0539\u027e\u053b\u027f\u053d\u0280\u053f\u0281\u0541\u0282\u0543\u0283"+ - "\u0545\u0284\u0547\u0285\u0549\u0286\u054b\u0287\u054d\u0288\u054f\u0289"+ - "\u0551\u028a\u0553\u028b\u0555\u028c\u0557\u028d\u0559\u028e\u055b\u028f"+ - "\u055d\u0290\u055f\u0291\u0561\u0292\u0563\u0293\u0565\u0294\u0567\u0295"+ - "\u0569\u0296\u056b\u0297\u056d\u0298\u056f\u0299\u0571\u029a\u0573\u029b"+ - "\u0575\u029c\u0577\u029d\u0579\u029e\u057b\u029f\u057d\u02a0\u057f\u02a1"+ - "\u0581\u02a2\u0583\u02a3\u0585\u02a4\u0587\u02a5\u0589\u02a6\u058b\u02a7"+ - "\u058d\u02a8\u058f\u02a9\u0591\u02aa\u0593\u02ab\u0595\u02ac\u0597\u02ad"+ - "\u0599\u02ae\u059b\u02af\u059d\u02b0\u059f\u02b1\u05a1\u02b2\u05a3\u02b3"+ - "\u05a5\u02b4\u05a7\u02b5\u05a9\u02b6\u05ab\u02b7\u05ad\u02b8\u05af\u02b9"+ - "\u05b1\u02ba\u05b3\u02bb\u05b5\u02bc\u05b7\u02bd\u05b9\u02be\u05bb\u02bf"+ - "\u05bd\u02c0\u05bf\u02c1\u05c1\u02c2\u05c3\u02c3\u05c5\u02c4\u05c7\u02c5"+ - "\u05c9\u02c6\u05cb\u02c7\u05cd\u02c8\u05cf\u02c9\u05d1\u02ca\u05d3\u02cb"+ - "\u05d5\u02cc\u05d7\u02cd\u05d9\u02ce\u05db\u02cf\u05dd\u02d0\u05df\u02d1"+ - "\u05e1\u02d2\u05e3\u02d3\u05e5\u02d4\u05e7\u02d5\u05e9\u02d6\u05eb\u02d7"+ - "\u05ed\u02d8\u05ef\u02d9\u05f1\u02da\u05f3\u02db\u05f5\u02dc\u05f7\u02dd"+ - "\u05f9\u02de\u05fb\u02df\u05fd\u02e0\u05ff\u02e1\u0601\u02e2\u0603\u02e3"+ - "\u0605\u02e4\u0607\u02e5\u0609\u02e6\u060b\u02e7\u060d\u02e8\u060f\u02e9"+ - "\u0611\u02ea\u0613\u02eb\u0615\u02ec\u0617\u02ed\u0619\u02ee\u061b\u02ef"+ - "\u061d\u02f0\u061f\u02f1\u0621\u02f2\u0623\u02f3\u0625\u02f4\u0627\u02f5"+ - "\u0629\u02f6\u062b\u02f7\u062d\u02f8\u062f\u02f9\u0631\u02fa\u0633\u02fb"+ - "\u0635\u02fc\u0637\u02fd\u0639\u02fe\u063b\u02ff\u063d\u0300\u063f\u0301"+ - "\u0641\u0302\u0643\u0303\u0645\u0304\u0647\u0305\u0649\u0306\u064b\u0307"+ - "\u064d\u0308\u064f\u0309\u0651\u030a\u0653\u030b\u0655\u030c\u0657\u030d"+ - "\u0659\u030e\u065b\u030f\u065d\u0310\u065f\u0311\u0661\u0312\u0663\u0313"+ - "\u0665\u0314\u0667\u0315\u0669\u0316\u066b\u0317\u066d\u0318\u066f\u0319"+ - "\u0671\u031a\u0673\u031b\u0675\u031c\u0677\u031d\u0679\u031e\u067b\u031f"+ - "\u067d\u0320\u067f\u0321\u0681\u0322\u0683\u0323\u0685\u0324\u0687\u0325"+ - "\u0689\u0326\u068b\u0327\u068d\u0328\u068f\u0329\u0691\u032a\u0693\u032b"+ - "\u0695\u032c\u0697\u032d\u0699\u032e\u069b\u032f\u069d\u0330\u069f\u0331"+ - "\u06a1\u0332\u06a3\u0333\u06a5\u0334\u06a7\u0335\u06a9\u0336\u06ab\u0337"+ - "\u06ad\u0338\u06af\u0339\u06b1\u033a\u06b3\u033b\u06b5\u033c\u06b7\u033d"+ - "\u06b9\u033e\u06bb\u033f\u06bd\u0340\u06bf\u0341\u06c1\u0342\u06c3\u0343"+ - "\u06c5\u0344\u06c7\u0345\u06c9\u0000\u0001\u0000$\u0003\u0000\t\n\r\r"+ - " \u0002\u0000AAaa\u0002\u0000BBbb\u0002\u0000CCcc\u0002\u0000DDdd\u0002"+ - "\u0000EEee\u0002\u0000FFff\u0002\u0000GGgg\u0002\u0000HHhh\u0002\u0000"+ - "IIii\u0002\u0000JJjj\u0002\u0000KKkk\u0002\u0000LLll\u0002\u0000MMmm\u0002"+ - "\u0000NNnn\u0002\u0000OOoo\u0002\u0000PPpp\u0002\u0000QQqq\u0002\u0000"+ - "RRrr\u0002\u0000SSss\u0002\u0000TTtt\u0002\u0000UUuu\u0002\u0000VVvv\u0002"+ - "\u0000WWww\u0002\u0000XXxx\u0002\u0000YYyy\u0002\u0000ZZzz\u0002\u0000"+ - "09AF\u0001\u000009\u0002\u0000\"\"\\\\\u0002\u0000\'\'\\\\\u0002\u0000"+ - "\\\\``\u0003\u0000AZ__az\u0005\u0000$$09AZ__az\u0004\u0000AZ__az\u00a1"+ - "\u8000\uffff\u0006\u0000$$09AZ__az\u00a1\u8000\uffff\u2200\u0000\u0001"+ - "\u0001\u0000\u0000\u0000\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005"+ - "\u0001\u0000\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001\u0000"+ - "\u0000\u0000\u0000I\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000\u0000"+ - "\u0000M\u0001\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000Q"+ - "\u0001\u0000\u0000\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001\u0000"+ - "\u0000\u0000\u0000W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000\u0000"+ - "\u0000[\u0001\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000_"+ - "\u0001\u0000\u0000\u0000\u0000a\u0001\u0000\u0000\u0000\u0000c\u0001\u0000"+ - "\u0000\u0000\u0000e\u0001\u0000\u0000\u0000\u0000g\u0001\u0000\u0000\u0000"+ - "\u0000i\u0001\u0000\u0000\u0000\u0000k\u0001\u0000\u0000\u0000\u0000m"+ - "\u0001\u0000\u0000\u0000\u0000o\u0001\u0000\u0000\u0000\u0000q\u0001\u0000"+ - "\u0000\u0000\u0000s\u0001\u0000\u0000\u0000\u0000u\u0001\u0000\u0000\u0000"+ - "\u0000w\u0001\u0000\u0000\u0000\u0000y\u0001\u0000\u0000\u0000\u0000{"+ - "\u0001\u0000\u0000\u0000\u0000}\u0001\u0000\u0000\u0000\u0000\u007f\u0001"+ - "\u0000\u0000\u0000\u0000\u0081\u0001\u0000\u0000\u0000\u0000\u0083\u0001"+ - "\u0000\u0000\u0000\u0000\u0085\u0001\u0000\u0000\u0000\u0000\u0087\u0001"+ - "\u0000\u0000\u0000\u0000\u0089\u0001\u0000\u0000\u0000\u0000\u008b\u0001"+ - "\u0000\u0000\u0000\u0000\u008d\u0001\u0000\u0000\u0000\u0000\u008f\u0001"+ - "\u0000\u0000\u0000\u0000\u0091\u0001\u0000\u0000\u0000\u0000\u0093\u0001"+ - "\u0000\u0000\u0000\u0000\u0095\u0001\u0000\u0000\u0000\u0000\u0097\u0001"+ - "\u0000\u0000\u0000\u0000\u0099\u0001\u0000\u0000\u0000\u0000\u009b\u0001"+ - "\u0000\u0000\u0000\u0000\u009d\u0001\u0000\u0000\u0000\u0000\u009f\u0001"+ - "\u0000\u0000\u0000\u0000\u00a1\u0001\u0000\u0000\u0000\u0000\u00a3\u0001"+ - "\u0000\u0000\u0000\u0000\u00a5\u0001\u0000\u0000\u0000\u0000\u00a7\u0001"+ - "\u0000\u0000\u0000\u0000\u00a9\u0001\u0000\u0000\u0000\u0000\u00ab\u0001"+ - "\u0000\u0000\u0000\u0000\u00ad\u0001\u0000\u0000\u0000\u0000\u00af\u0001"+ - "\u0000\u0000\u0000\u0000\u00b1\u0001\u0000\u0000\u0000\u0000\u00b3\u0001"+ - "\u0000\u0000\u0000\u0000\u00b5\u0001\u0000\u0000\u0000\u0000\u00b7\u0001"+ - "\u0000\u0000\u0000\u0000\u00b9\u0001\u0000\u0000\u0000\u0000\u00bb\u0001"+ - "\u0000\u0000\u0000\u0000\u00bd\u0001\u0000\u0000\u0000\u0000\u00bf\u0001"+ - "\u0000\u0000\u0000\u0000\u00c1\u0001\u0000\u0000\u0000\u0000\u00c3\u0001"+ - "\u0000\u0000\u0000\u0000\u00c5\u0001\u0000\u0000\u0000\u0000\u00c7\u0001"+ - "\u0000\u0000\u0000\u0000\u00c9\u0001\u0000\u0000\u0000\u0000\u00cb\u0001"+ - "\u0000\u0000\u0000\u0000\u00cd\u0001\u0000\u0000\u0000\u0000\u00cf\u0001"+ - "\u0000\u0000\u0000\u0000\u00d1\u0001\u0000\u0000\u0000\u0000\u00d3\u0001"+ - "\u0000\u0000\u0000\u0000\u00d5\u0001\u0000\u0000\u0000\u0000\u00d7\u0001"+ - "\u0000\u0000\u0000\u0000\u00d9\u0001\u0000\u0000\u0000\u0000\u00db\u0001"+ - "\u0000\u0000\u0000\u0000\u00dd\u0001\u0000\u0000\u0000\u0000\u00df\u0001"+ - "\u0000\u0000\u0000\u0000\u00e1\u0001\u0000\u0000\u0000\u0000\u00e3\u0001"+ - "\u0000\u0000\u0000\u0000\u00e5\u0001\u0000\u0000\u0000\u0000\u00e7\u0001"+ - "\u0000\u0000\u0000\u0000\u00e9\u0001\u0000\u0000\u0000\u0000\u00eb\u0001"+ - "\u0000\u0000\u0000\u0000\u00ed\u0001\u0000\u0000\u0000\u0000\u00ef\u0001"+ - "\u0000\u0000\u0000\u0000\u00f1\u0001\u0000\u0000\u0000\u0000\u00f3\u0001"+ - "\u0000\u0000\u0000\u0000\u00f5\u0001\u0000\u0000\u0000\u0000\u00f7\u0001"+ - "\u0000\u0000\u0000\u0000\u00f9\u0001\u0000\u0000\u0000\u0000\u00fb\u0001"+ - "\u0000\u0000\u0000\u0000\u00fd\u0001\u0000\u0000\u0000\u0000\u00ff\u0001"+ - "\u0000\u0000\u0000\u0000\u0101\u0001\u0000\u0000\u0000\u0000\u0103\u0001"+ - "\u0000\u0000\u0000\u0000\u0105\u0001\u0000\u0000\u0000\u0000\u0107\u0001"+ - "\u0000\u0000\u0000\u0000\u0109\u0001\u0000\u0000\u0000\u0000\u010b\u0001"+ - "\u0000\u0000\u0000\u0000\u010d\u0001\u0000\u0000\u0000\u0000\u010f\u0001"+ - "\u0000\u0000\u0000\u0000\u0111\u0001\u0000\u0000\u0000\u0000\u0113\u0001"+ - "\u0000\u0000\u0000\u0000\u0115\u0001\u0000\u0000\u0000\u0000\u0117\u0001"+ - "\u0000\u0000\u0000\u0000\u0119\u0001\u0000\u0000\u0000\u0000\u011b\u0001"+ - "\u0000\u0000\u0000\u0000\u011d\u0001\u0000\u0000\u0000\u0000\u011f\u0001"+ - "\u0000\u0000\u0000\u0000\u0121\u0001\u0000\u0000\u0000\u0000\u0123\u0001"+ - "\u0000\u0000\u0000\u0000\u0125\u0001\u0000\u0000\u0000\u0000\u0127\u0001"+ - "\u0000\u0000\u0000\u0000\u0129\u0001\u0000\u0000\u0000\u0000\u012b\u0001"+ - "\u0000\u0000\u0000\u0000\u012d\u0001\u0000\u0000\u0000\u0000\u012f\u0001"+ - "\u0000\u0000\u0000\u0000\u0131\u0001\u0000\u0000\u0000\u0000\u0133\u0001"+ - "\u0000\u0000\u0000\u0000\u0135\u0001\u0000\u0000\u0000\u0000\u0137\u0001"+ - "\u0000\u0000\u0000\u0000\u0139\u0001\u0000\u0000\u0000\u0000\u013b\u0001"+ - "\u0000\u0000\u0000\u0000\u013d\u0001\u0000\u0000\u0000\u0000\u013f\u0001"+ - "\u0000\u0000\u0000\u0000\u0141\u0001\u0000\u0000\u0000\u0000\u0143\u0001"+ - "\u0000\u0000\u0000\u0000\u0145\u0001\u0000\u0000\u0000\u0000\u0147\u0001"+ - "\u0000\u0000\u0000\u0000\u0149\u0001\u0000\u0000\u0000\u0000\u014b\u0001"+ - "\u0000\u0000\u0000\u0000\u014d\u0001\u0000\u0000\u0000\u0000\u014f\u0001"+ - "\u0000\u0000\u0000\u0000\u0151\u0001\u0000\u0000\u0000\u0000\u0153\u0001"+ - "\u0000\u0000\u0000\u0000\u0155\u0001\u0000\u0000\u0000\u0000\u0157\u0001"+ - "\u0000\u0000\u0000\u0000\u0159\u0001\u0000\u0000\u0000\u0000\u015b\u0001"+ - "\u0000\u0000\u0000\u0000\u015d\u0001\u0000\u0000\u0000\u0000\u015f\u0001"+ - "\u0000\u0000\u0000\u0000\u0161\u0001\u0000\u0000\u0000\u0000\u0163\u0001"+ - "\u0000\u0000\u0000\u0000\u0165\u0001\u0000\u0000\u0000\u0000\u0167\u0001"+ - "\u0000\u0000\u0000\u0000\u0169\u0001\u0000\u0000\u0000\u0000\u016b\u0001"+ - "\u0000\u0000\u0000\u0000\u016d\u0001\u0000\u0000\u0000\u0000\u016f\u0001"+ - "\u0000\u0000\u0000\u0000\u0171\u0001\u0000\u0000\u0000\u0000\u0173\u0001"+ - "\u0000\u0000\u0000\u0000\u0175\u0001\u0000\u0000\u0000\u0000\u0177\u0001"+ - "\u0000\u0000\u0000\u0000\u0179\u0001\u0000\u0000\u0000\u0000\u017b\u0001"+ - "\u0000\u0000\u0000\u0000\u017d\u0001\u0000\u0000\u0000\u0000\u017f\u0001"+ - "\u0000\u0000\u0000\u0000\u0181\u0001\u0000\u0000\u0000\u0000\u0183\u0001"+ - "\u0000\u0000\u0000\u0000\u0185\u0001\u0000\u0000\u0000\u0000\u0187\u0001"+ - "\u0000\u0000\u0000\u0000\u0189\u0001\u0000\u0000\u0000\u0000\u018b\u0001"+ - "\u0000\u0000\u0000\u0000\u018d\u0001\u0000\u0000\u0000\u0000\u018f\u0001"+ - "\u0000\u0000\u0000\u0000\u0191\u0001\u0000\u0000\u0000\u0000\u0193\u0001"+ - "\u0000\u0000\u0000\u0000\u0195\u0001\u0000\u0000\u0000\u0000\u0197\u0001"+ - "\u0000\u0000\u0000\u0000\u0199\u0001\u0000\u0000\u0000\u0000\u019b\u0001"+ - "\u0000\u0000\u0000\u0000\u019d\u0001\u0000\u0000\u0000\u0000\u019f\u0001"+ - "\u0000\u0000\u0000\u0000\u01a1\u0001\u0000\u0000\u0000\u0000\u01a3\u0001"+ - "\u0000\u0000\u0000\u0000\u01a5\u0001\u0000\u0000\u0000\u0000\u01a7\u0001"+ - "\u0000\u0000\u0000\u0000\u01a9\u0001\u0000\u0000\u0000\u0000\u01ab\u0001"+ - "\u0000\u0000\u0000\u0000\u01ad\u0001\u0000\u0000\u0000\u0000\u01af\u0001"+ - "\u0000\u0000\u0000\u0000\u01b1\u0001\u0000\u0000\u0000\u0000\u01b3\u0001"+ - "\u0000\u0000\u0000\u0000\u01b5\u0001\u0000\u0000\u0000\u0000\u01b7\u0001"+ - "\u0000\u0000\u0000\u0000\u01b9\u0001\u0000\u0000\u0000\u0000\u01bb\u0001"+ - "\u0000\u0000\u0000\u0000\u01bd\u0001\u0000\u0000\u0000\u0000\u01bf\u0001"+ - "\u0000\u0000\u0000\u0000\u01c1\u0001\u0000\u0000\u0000\u0000\u01c3\u0001"+ - "\u0000\u0000\u0000\u0000\u01c5\u0001\u0000\u0000\u0000\u0000\u01c7\u0001"+ - "\u0000\u0000\u0000\u0000\u01c9\u0001\u0000\u0000\u0000\u0000\u01cb\u0001"+ - "\u0000\u0000\u0000\u0000\u01cd\u0001\u0000\u0000\u0000\u0000\u01cf\u0001"+ - "\u0000\u0000\u0000\u0000\u01d1\u0001\u0000\u0000\u0000\u0000\u01d3\u0001"+ - "\u0000\u0000\u0000\u0000\u01d5\u0001\u0000\u0000\u0000\u0000\u01d7\u0001"+ - "\u0000\u0000\u0000\u0000\u01d9\u0001\u0000\u0000\u0000\u0000\u01db\u0001"+ - "\u0000\u0000\u0000\u0000\u01dd\u0001\u0000\u0000\u0000\u0000\u01df\u0001"+ - "\u0000\u0000\u0000\u0000\u01e1\u0001\u0000\u0000\u0000\u0000\u01e3\u0001"+ - "\u0000\u0000\u0000\u0000\u01e5\u0001\u0000\u0000\u0000\u0000\u01e7\u0001"+ - "\u0000\u0000\u0000\u0000\u01e9\u0001\u0000\u0000\u0000\u0000\u01eb\u0001"+ - "\u0000\u0000\u0000\u0000\u01ed\u0001\u0000\u0000\u0000\u0000\u01ef\u0001"+ - "\u0000\u0000\u0000\u0000\u01f1\u0001\u0000\u0000\u0000\u0000\u01f3\u0001"+ - "\u0000\u0000\u0000\u0000\u01f5\u0001\u0000\u0000\u0000\u0000\u01f7\u0001"+ - "\u0000\u0000\u0000\u0000\u01f9\u0001\u0000\u0000\u0000\u0000\u01fb\u0001"+ - "\u0000\u0000\u0000\u0000\u01fd\u0001\u0000\u0000\u0000\u0000\u01ff\u0001"+ - "\u0000\u0000\u0000\u0000\u0201\u0001\u0000\u0000\u0000\u0000\u0203\u0001"+ - "\u0000\u0000\u0000\u0000\u0205\u0001\u0000\u0000\u0000\u0000\u0207\u0001"+ - "\u0000\u0000\u0000\u0000\u0209\u0001\u0000\u0000\u0000\u0000\u020b\u0001"+ - "\u0000\u0000\u0000\u0000\u020d\u0001\u0000\u0000\u0000\u0000\u020f\u0001"+ - "\u0000\u0000\u0000\u0000\u0211\u0001\u0000\u0000\u0000\u0000\u0213\u0001"+ - "\u0000\u0000\u0000\u0000\u0215\u0001\u0000\u0000\u0000\u0000\u0217\u0001"+ - "\u0000\u0000\u0000\u0000\u0219\u0001\u0000\u0000\u0000\u0000\u021b\u0001"+ - "\u0000\u0000\u0000\u0000\u021d\u0001\u0000\u0000\u0000\u0000\u021f\u0001"+ - "\u0000\u0000\u0000\u0000\u0221\u0001\u0000\u0000\u0000\u0000\u0223\u0001"+ - "\u0000\u0000\u0000\u0000\u0225\u0001\u0000\u0000\u0000\u0000\u0227\u0001"+ - "\u0000\u0000\u0000\u0000\u0229\u0001\u0000\u0000\u0000\u0000\u022b\u0001"+ - "\u0000\u0000\u0000\u0000\u022d\u0001\u0000\u0000\u0000\u0000\u022f\u0001"+ - "\u0000\u0000\u0000\u0000\u0231\u0001\u0000\u0000\u0000\u0000\u0233\u0001"+ - "\u0000\u0000\u0000\u0000\u0235\u0001\u0000\u0000\u0000\u0000\u0237\u0001"+ - "\u0000\u0000\u0000\u0000\u0239\u0001\u0000\u0000\u0000\u0000\u023b\u0001"+ - "\u0000\u0000\u0000\u0000\u023d\u0001\u0000\u0000\u0000\u0000\u023f\u0001"+ - "\u0000\u0000\u0000\u0000\u0241\u0001\u0000\u0000\u0000\u0000\u0243\u0001"+ - "\u0000\u0000\u0000\u0000\u0245\u0001\u0000\u0000\u0000\u0000\u0247\u0001"+ - "\u0000\u0000\u0000\u0000\u0249\u0001\u0000\u0000\u0000\u0000\u024b\u0001"+ - "\u0000\u0000\u0000\u0000\u024d\u0001\u0000\u0000\u0000\u0000\u024f\u0001"+ - "\u0000\u0000\u0000\u0000\u0251\u0001\u0000\u0000\u0000\u0000\u0253\u0001"+ - "\u0000\u0000\u0000\u0000\u0255\u0001\u0000\u0000\u0000\u0000\u0257\u0001"+ - "\u0000\u0000\u0000\u0000\u0259\u0001\u0000\u0000\u0000\u0000\u025b\u0001"+ - "\u0000\u0000\u0000\u0000\u025d\u0001\u0000\u0000\u0000\u0000\u025f\u0001"+ - "\u0000\u0000\u0000\u0000\u0261\u0001\u0000\u0000\u0000\u0000\u0263\u0001"+ - "\u0000\u0000\u0000\u0000\u0265\u0001\u0000\u0000\u0000\u0000\u0267\u0001"+ - "\u0000\u0000\u0000\u0000\u0269\u0001\u0000\u0000\u0000\u0000\u026b\u0001"+ - "\u0000\u0000\u0000\u0000\u026d\u0001\u0000\u0000\u0000\u0000\u026f\u0001"+ - "\u0000\u0000\u0000\u0000\u0271\u0001\u0000\u0000\u0000\u0000\u0273\u0001"+ - "\u0000\u0000\u0000\u0000\u0275\u0001\u0000\u0000\u0000\u0000\u0277\u0001"+ - "\u0000\u0000\u0000\u0000\u0279\u0001\u0000\u0000\u0000\u0000\u027b\u0001"+ - "\u0000\u0000\u0000\u0000\u027d\u0001\u0000\u0000\u0000\u0000\u027f\u0001"+ - "\u0000\u0000\u0000\u0000\u0281\u0001\u0000\u0000\u0000\u0000\u0283\u0001"+ - "\u0000\u0000\u0000\u0000\u0285\u0001\u0000\u0000\u0000\u0000\u0287\u0001"+ - "\u0000\u0000\u0000\u0000\u0289\u0001\u0000\u0000\u0000\u0000\u028b\u0001"+ - "\u0000\u0000\u0000\u0000\u028d\u0001\u0000\u0000\u0000\u0000\u028f\u0001"+ - "\u0000\u0000\u0000\u0000\u0291\u0001\u0000\u0000\u0000\u0000\u0293\u0001"+ - "\u0000\u0000\u0000\u0000\u0295\u0001\u0000\u0000\u0000\u0000\u0297\u0001"+ - "\u0000\u0000\u0000\u0000\u0299\u0001\u0000\u0000\u0000\u0000\u029b\u0001"+ - "\u0000\u0000\u0000\u0000\u029d\u0001\u0000\u0000\u0000\u0000\u029f\u0001"+ - "\u0000\u0000\u0000\u0000\u02a1\u0001\u0000\u0000\u0000\u0000\u02a3\u0001"+ - "\u0000\u0000\u0000\u0000\u02a5\u0001\u0000\u0000\u0000\u0000\u02a7\u0001"+ - "\u0000\u0000\u0000\u0000\u02a9\u0001\u0000\u0000\u0000\u0000\u02ab\u0001"+ - "\u0000\u0000\u0000\u0000\u02ad\u0001\u0000\u0000\u0000\u0000\u02af\u0001"+ - "\u0000\u0000\u0000\u0000\u02b1\u0001\u0000\u0000\u0000\u0000\u02b3\u0001"+ - "\u0000\u0000\u0000\u0000\u02b5\u0001\u0000\u0000\u0000\u0000\u02b7\u0001"+ - "\u0000\u0000\u0000\u0000\u02b9\u0001\u0000\u0000\u0000\u0000\u02bb\u0001"+ - "\u0000\u0000\u0000\u0000\u02bd\u0001\u0000\u0000\u0000\u0000\u02bf\u0001"+ - "\u0000\u0000\u0000\u0000\u02c1\u0001\u0000\u0000\u0000\u0000\u02c3\u0001"+ - "\u0000\u0000\u0000\u0000\u02c5\u0001\u0000\u0000\u0000\u0000\u02c7\u0001"+ - "\u0000\u0000\u0000\u0000\u02c9\u0001\u0000\u0000\u0000\u0000\u02cb\u0001"+ - "\u0000\u0000\u0000\u0000\u02cd\u0001\u0000\u0000\u0000\u0000\u02cf\u0001"+ - "\u0000\u0000\u0000\u0000\u02d1\u0001\u0000\u0000\u0000\u0000\u02d3\u0001"+ - "\u0000\u0000\u0000\u0000\u02d5\u0001\u0000\u0000\u0000\u0000\u02d7\u0001"+ - "\u0000\u0000\u0000\u0000\u02d9\u0001\u0000\u0000\u0000\u0000\u02db\u0001"+ - "\u0000\u0000\u0000\u0000\u02dd\u0001\u0000\u0000\u0000\u0000\u02df\u0001"+ - "\u0000\u0000\u0000\u0000\u02e1\u0001\u0000\u0000\u0000\u0000\u02e3\u0001"+ - "\u0000\u0000\u0000\u0000\u02e5\u0001\u0000\u0000\u0000\u0000\u02e7\u0001"+ - "\u0000\u0000\u0000\u0000\u02e9\u0001\u0000\u0000\u0000\u0000\u02eb\u0001"+ - "\u0000\u0000\u0000\u0000\u02ed\u0001\u0000\u0000\u0000\u0000\u02ef\u0001"+ - "\u0000\u0000\u0000\u0000\u02f1\u0001\u0000\u0000\u0000\u0000\u02f3\u0001"+ - "\u0000\u0000\u0000\u0000\u02f5\u0001\u0000\u0000\u0000\u0000\u02f7\u0001"+ - "\u0000\u0000\u0000\u0000\u02f9\u0001\u0000\u0000\u0000\u0000\u02fb\u0001"+ - "\u0000\u0000\u0000\u0000\u02fd\u0001\u0000\u0000\u0000\u0000\u02ff\u0001"+ - "\u0000\u0000\u0000\u0000\u0301\u0001\u0000\u0000\u0000\u0000\u0303\u0001"+ - "\u0000\u0000\u0000\u0000\u0305\u0001\u0000\u0000\u0000\u0000\u0307\u0001"+ - "\u0000\u0000\u0000\u0000\u0309\u0001\u0000\u0000\u0000\u0000\u030b\u0001"+ - "\u0000\u0000\u0000\u0000\u030d\u0001\u0000\u0000\u0000\u0000\u030f\u0001"+ - "\u0000\u0000\u0000\u0000\u0311\u0001\u0000\u0000\u0000\u0000\u0313\u0001"+ - "\u0000\u0000\u0000\u0000\u0315\u0001\u0000\u0000\u0000\u0000\u0317\u0001"+ - "\u0000\u0000\u0000\u0000\u0319\u0001\u0000\u0000\u0000\u0000\u031b\u0001"+ - "\u0000\u0000\u0000\u0000\u031d\u0001\u0000\u0000\u0000\u0000\u031f\u0001"+ - "\u0000\u0000\u0000\u0000\u0321\u0001\u0000\u0000\u0000\u0000\u0323\u0001"+ - "\u0000\u0000\u0000\u0000\u0325\u0001\u0000\u0000\u0000\u0000\u0327\u0001"+ - "\u0000\u0000\u0000\u0000\u0329\u0001\u0000\u0000\u0000\u0000\u032b\u0001"+ - "\u0000\u0000\u0000\u0000\u032d\u0001\u0000\u0000\u0000\u0000\u032f\u0001"+ - "\u0000\u0000\u0000\u0000\u0331\u0001\u0000\u0000\u0000\u0000\u0333\u0001"+ - "\u0000\u0000\u0000\u0000\u0335\u0001\u0000\u0000\u0000\u0000\u0337\u0001"+ - "\u0000\u0000\u0000\u0000\u0339\u0001\u0000\u0000\u0000\u0000\u033b\u0001"+ - "\u0000\u0000\u0000\u0000\u033d\u0001\u0000\u0000\u0000\u0000\u033f\u0001"+ - "\u0000\u0000\u0000\u0000\u0341\u0001\u0000\u0000\u0000\u0000\u0343\u0001"+ - "\u0000\u0000\u0000\u0000\u0345\u0001\u0000\u0000\u0000\u0000\u0347\u0001"+ - "\u0000\u0000\u0000\u0000\u0349\u0001\u0000\u0000\u0000\u0000\u034b\u0001"+ - "\u0000\u0000\u0000\u0000\u034d\u0001\u0000\u0000\u0000\u0000\u034f\u0001"+ - "\u0000\u0000\u0000\u0000\u0351\u0001\u0000\u0000\u0000\u0000\u0353\u0001"+ - "\u0000\u0000\u0000\u0000\u0355\u0001\u0000\u0000\u0000\u0000\u0357\u0001"+ - "\u0000\u0000\u0000\u0000\u0359\u0001\u0000\u0000\u0000\u0000\u035b\u0001"+ - "\u0000\u0000\u0000\u0000\u035d"; + "\u0005\u0290\u1921\b\u0290\n\u0290\f\u0290\u1924\t\u0290\u0001\u0291\u0001"+ + "\u0291\u0001\u0291\u0001\u0291\u0001\u0291\u0001\u0291\u0001\u0292\u0001"+ + "\u0292\u0001\u0292\u0001\u0293\u0001\u0293\u0001\u0293\u0001\u0293\u0001"+ + "\u0294\u0001\u0294\u0003\u0294\u1935\b\u0294\u0001\u0294\u0001\u0294\u0001"+ + "\u0294\u0001\u0294\u0001\u0294\u0001\u0295\u0001\u0295\u0005\u0295\u193e"+ + "\b\u0295\n\u0295\f\u0295\u1941\t\u0295\u0001\u0296\u0001\u0296\u0001\u0296"+ + "\u0001\u0297\u0001\u0297\u0001\u0297\u0005\u0297\u1949\b\u0297\n\u0297"+ + "\f\u0297\u194c\t\u0297\u0001\u0298\u0001\u0298\u0001\u0298\u0001\u0299"+ + "\u0001\u0299\u0001\u0299\u0001\u029a\u0001\u029a\u0001\u029a\u0001\u029b"+ + "\u0001\u029b\u0001\u029b\u0005\u029b\u195a\b\u029b\n\u029b\f\u029b\u195d"+ + "\t\u029b\u0001\u029c\u0001\u029c\u0001\u029c\u0001\u029d\u0001\u029d\u0001"+ + "\u029d\u0001\u029e\u0001\u029e\u0001\u029f\u0001\u029f\u0001\u029f\u0001"+ + "\u029f\u0001\u029f\u0001\u029f\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0003"+ + "\u02a0\u1970\b\u02a0\u0001\u02a0\u0001\u02a0\u0003\u02a0\u1974\b\u02a0"+ + "\u0001\u02a0\u0003\u02a0\u1977\b\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a0"+ + "\u0001\u02a0\u0003\u02a0\u197d\b\u02a0\u0001\u02a0\u0003\u02a0\u1980\b"+ + "\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0003\u02a0\u1985\b\u02a0\u0001"+ + "\u02a0\u0001\u02a0\u0003\u02a0\u1989\b\u02a0\u0001\u02a1\u0004\u02a1\u198c"+ + "\b\u02a1\u000b\u02a1\f\u02a1\u198d\u0001\u02a2\u0001\u02a2\u0001\u02a2"+ + "\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0005\u02a2"+ + "\u1998\b\u02a2\n\u02a2\f\u02a2\u199b\t\u02a2\u0001\u02a2\u0001\u02a2\u0001"+ + "\u02a3\u0004\u02a3\u19a0\b\u02a3\u000b\u02a3\f\u02a3\u19a1\u0001\u02a3"+ + "\u0001\u02a3\u0001\u02a4\u0001\u02a4\u0003\u02a4\u19a8\b\u02a4\u0001\u02a4"+ + "\u0003\u02a4\u19ab\b\u02a4\u0001\u02a4\u0001\u02a4\u0001\u02a5\u0001\u02a5"+ + "\u0001\u02a5\u0001\u02a5\u0005\u02a5\u19b3\b\u02a5\n\u02a5\f\u02a5\u19b6"+ + "\t\u02a5\u0001\u02a5\u0001\u02a5\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001"+ + "\u02a6\u0005\u02a6\u19be\b\u02a6\n\u02a6\f\u02a6\u19c1\t\u02a6\u0001\u02a6"+ + "\u0001\u02a6\u0001\u02a6\u0004\u02a6\u19c6\b\u02a6\u000b\u02a6\f\u02a6"+ + "\u19c7\u0001\u02a6\u0001\u02a6\u0004\u02a6\u19cc\b\u02a6\u000b\u02a6\f"+ + "\u02a6\u19cd\u0001\u02a6\u0005\u02a6\u19d1\b\u02a6\n\u02a6\f\u02a6\u19d4"+ + "\t\u02a6\u0001\u02a6\u0005\u02a6\u19d7\b\u02a6\n\u02a6\f\u02a6\u19da\t"+ + "\u02a6\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001\u02a6\u0001"+ + "\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0005\u02a7\u19e5\b\u02a7\n"+ + "\u02a7\f\u02a7\u19e8\t\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0004"+ + "\u02a7\u19ed\b\u02a7\u000b\u02a7\f\u02a7\u19ee\u0001\u02a7\u0001\u02a7"+ + "\u0004\u02a7\u19f3\b\u02a7\u000b\u02a7\f\u02a7\u19f4\u0001\u02a7\u0003"+ + "\u02a7\u19f8\b\u02a7\u0005\u02a7\u19fa\b\u02a7\n\u02a7\f\u02a7\u19fd\t"+ + "\u02a7\u0001\u02a7\u0004\u02a7\u1a00\b\u02a7\u000b\u02a7\f\u02a7\u1a01"+ + "\u0001\u02a7\u0004\u02a7\u1a05\b\u02a7\u000b\u02a7\f\u02a7\u1a06\u0001"+ + "\u02a7\u0005\u02a7\u1a0a\b\u02a7\n\u02a7\f\u02a7\u1a0d\t\u02a7\u0001\u02a7"+ + "\u0003\u02a7\u1a10\b\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a8\u0001\u02a8"+ + "\u0001\u02a8\u0001\u02a8\u0005\u02a8\u1a18\b\u02a8\n\u02a8\f\u02a8\u1a1b"+ + "\t\u02a8\u0001\u02a8\u0005\u02a8\u1a1e\b\u02a8\n\u02a8\f\u02a8\u1a21\t"+ + "\u02a8\u0001\u02a8\u0001\u02a8\u0005\u02a8\u1a25\b\u02a8\n\u02a8\f\u02a8"+ + "\u1a28\t\u02a8\u0003\u02a8\u1a2a\b\u02a8\u0001\u02a9\u0001\u02a9\u0001"+ + "\u02a9\u0001\u02aa\u0001\u02aa\u0001\u02ab\u0001\u02ab\u0001\u02ab\u0001"+ + "\u02ab\u0001\u02ab\u0001\u02ac\u0001\u02ac\u0003\u02ac\u1a38\b\u02ac\u0001"+ + "\u02ac\u0001\u02ac\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001"+ + "\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001"+ + "\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001"+ + "\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001"+ + "\u02ad\u0003\u02ad\u1a53\b\u02ad\u0001\u02ad\u0005\u02ad\u1a56\b\u02ad"+ + "\n\u02ad\f\u02ad\u1a59\t\u02ad\u0001\u02ae\u0001\u02ae\u0001\u02ae\u0001"+ + "\u02ae\u0001\u02ae\u0001\u02af\u0001\u02af\u0003\u02af\u1a62\b\u02af\u0001"+ + "\u02af\u0001\u02af\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001"+ + "\u02b0\u0005\u02b0\u1a6b\b\u02b0\n\u02b0\f\u02b0\u1a6e\t\u02b0\u0001\u02b1"+ + "\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b2\u0001\u02b2"+ + "\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b3\u0001\u02b3"+ + "\u0001\u02b3\u0001\u02b3\u0001\u02b3\u0001\u02b4\u0001\u02b4\u0001\u02b4"+ + "\u0001\u02b4\u0001\u02b4\u0001\u02b5\u0001\u02b5\u0001\u02b5\u0001\u02b5"+ + "\u0001\u02b5\u0001\u02b6\u0004\u02b6\u1a8b\b\u02b6\u000b\u02b6\f\u02b6"+ + "\u1a8c\u0001\u02b6\u0001\u02b6\u0005\u02b6\u1a91\b\u02b6\n\u02b6\f\u02b6"+ + "\u1a94\t\u02b6\u0003\u02b6\u1a96\b\u02b6\u0001\u02b7\u0001\u02b7\u0003"+ + "\u02b7\u1a9a\b\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001\u02b7\u0001"+ + "\u02b7\u0001\u02b7\u0001\u02b7\u0001\u057e\u0000\u02b8\u0005\u0001\u0007"+ + "\u0000\t\u0002\u000b\u0003\r\u0004\u000f\u0005\u0011\u0006\u0013\u0007"+ + "\u0015\b\u0017\t\u0019\n\u001b\u000b\u001d\f\u001f\r!\u000e#\u000f%\u0010"+ + "\'\u0011)\u0012+\u0013-\u0014/\u00151\u00163\u00175\u00187\u00199\u001a"+ + ";\u001b=\u001c?\u001dA\u001eC\u001fE\u0000G\u0000I\u0000K\u0000M O!Q\""+ + "S#U$W%Y&[\'](_)a*c+e,g-i.k/m0o1q2s3u4w5y6{7}8\u007f9\u0081:\u0083;\u0085"+ + "<\u0087=\u0089>\u008b?\u008d@\u008fA\u0091B\u0093C\u0095D\u0097E\u0099"+ + "F\u009bG\u009dH\u009fI\u00a1J\u00a3K\u00a5L\u00a7M\u00a9N\u00abO\u00ad"+ + "P\u00afQ\u00b1R\u00b3S\u00b5T\u00b7U\u00b9V\u00bbW\u00bdX\u00bfY\u00c1"+ + "Z\u00c3[\u00c5\\\u00c7]\u00c9^\u00cb_\u00cd`\u00cfa\u00d1b\u00d3c\u00d5"+ + "d\u00d7e\u00d9f\u00dbg\u00ddh\u00dfi\u00e1j\u00e3k\u00e5l\u00e7m\u00e9"+ + "n\u00ebo\u00edp\u00efq\u00f1r\u00f3s\u00f5t\u00f7u\u00f9v\u00fbw\u00fd"+ + "x\u00ffy\u0101z\u0103{\u0105|\u0107}\u0109~\u010b\u007f\u010d\u0080\u010f"+ + "\u0081\u0111\u0082\u0113\u0083\u0115\u0084\u0117\u0085\u0119\u0086\u011b"+ + "\u0087\u011d\u0088\u011f\u0089\u0121\u008a\u0123\u008b\u0125\u008c\u0127"+ + "\u008d\u0129\u008e\u012b\u008f\u012d\u0090\u012f\u0091\u0131\u0092\u0133"+ + "\u0093\u0135\u0094\u0137\u0095\u0139\u0096\u013b\u0097\u013d\u0098\u013f"+ + "\u0099\u0141\u009a\u0143\u009b\u0145\u009c\u0147\u009d\u0149\u009e\u014b"+ + "\u009f\u014d\u00a0\u014f\u00a1\u0151\u00a2\u0153\u00a3\u0155\u00a4\u0157"+ + "\u00a5\u0159\u00a6\u015b\u00a7\u015d\u00a8\u015f\u00a9\u0161\u00aa\u0163"+ + "\u00ab\u0165\u00ac\u0167\u00ad\u0169\u00ae\u016b\u00af\u016d\u00b0\u016f"+ + "\u00b1\u0171\u00b2\u0173\u00b3\u0175\u00b4\u0177\u00b5\u0179\u00b6\u017b"+ + "\u00b7\u017d\u00b8\u017f\u00b9\u0181\u00ba\u0183\u00bb\u0185\u00bc\u0187"+ + "\u00bd\u0189\u00be\u018b\u00bf\u018d\u00c0\u018f\u00c1\u0191\u00c2\u0193"+ + "\u00c3\u0195\u00c4\u0197\u00c5\u0199\u00c6\u019b\u00c7\u019d\u00c8\u019f"+ + "\u00c9\u01a1\u00ca\u01a3\u00cb\u01a5\u00cc\u01a7\u00cd\u01a9\u00ce\u01ab"+ + "\u00cf\u01ad\u00d0\u01af\u00d1\u01b1\u00d2\u01b3\u00d3\u01b5\u00d4\u01b7"+ + "\u00d5\u01b9\u00d6\u01bb\u00d7\u01bd\u00d8\u01bf\u00d9\u01c1\u00da\u01c3"+ + "\u00db\u01c5\u00dc\u01c7\u00dd\u01c9\u00de\u01cb\u00df\u01cd\u00e0\u01cf"+ + "\u00e1\u01d1\u00e2\u01d3\u00e3\u01d5\u00e4\u01d7\u00e5\u01d9\u00e6\u01db"+ + "\u00e7\u01dd\u00e8\u01df\u00e9\u01e1\u00ea\u01e3\u00eb\u01e5\u00ec\u01e7"+ + "\u00ed\u01e9\u00ee\u01eb\u00ef\u01ed\u00f0\u01ef\u00f1\u01f1\u00f2\u01f3"+ + "\u00f3\u01f5\u00f4\u01f7\u00f5\u01f9\u00f6\u01fb\u00f7\u01fd\u00f8\u01ff"+ + "\u00f9\u0201\u00fa\u0203\u00fb\u0205\u00fc\u0207\u00fd\u0209\u00fe\u020b"+ + "\u00ff\u020d\u0100\u020f\u0101\u0211\u0102\u0213\u0103\u0215\u0104\u0217"+ + "\u0105\u0219\u0106\u021b\u0107\u021d\u0108\u021f\u0109\u0221\u010a\u0223"+ + "\u010b\u0225\u010c\u0227\u010d\u0229\u010e\u022b\u010f\u022d\u0110\u022f"+ + "\u0111\u0231\u0112\u0233\u0113\u0235\u0114\u0237\u0115\u0239\u0116\u023b"+ + "\u0117\u023d\u0118\u023f\u0119\u0241\u011a\u0243\u011b\u0245\u011c\u0247"+ + "\u011d\u0249\u011e\u024b\u011f\u024d\u0120\u024f\u0121\u0251\u0122\u0253"+ + "\u0123\u0255\u0124\u0257\u0125\u0259\u0126\u025b\u0127\u025d\u0128\u025f"+ + "\u0129\u0261\u012a\u0263\u012b\u0265\u012c\u0267\u012d\u0269\u012e\u026b"+ + "\u012f\u026d\u0130\u026f\u0131\u0271\u0132\u0273\u0133\u0275\u0134\u0277"+ + "\u0135\u0279\u0136\u027b\u0137\u027d\u0138\u027f\u0139\u0281\u013a\u0283"+ + "\u013b\u0285\u013c\u0287\u013d\u0289\u013e\u028b\u013f\u028d\u0140\u028f"+ + "\u0141\u0291\u0142\u0293\u0143\u0295\u0144\u0297\u0145\u0299\u0146\u029b"+ + "\u0147\u029d\u0148\u029f\u0149\u02a1\u014a\u02a3\u014b\u02a5\u014c\u02a7"+ + "\u014d\u02a9\u014e\u02ab\u014f\u02ad\u0150\u02af\u0151\u02b1\u0152\u02b3"+ + "\u0153\u02b5\u0154\u02b7\u0155\u02b9\u0156\u02bb\u0157\u02bd\u0158\u02bf"+ + "\u0159\u02c1\u015a\u02c3\u015b\u02c5\u015c\u02c7\u015d\u02c9\u015e\u02cb"+ + "\u015f\u02cd\u0160\u02cf\u0161\u02d1\u0162\u02d3\u0163\u02d5\u0164\u02d7"+ + "\u0165\u02d9\u0166\u02db\u0167\u02dd\u0168\u02df\u0169\u02e1\u016a\u02e3"+ + "\u016b\u02e5\u016c\u02e7\u016d\u02e9\u016e\u02eb\u016f\u02ed\u0170\u02ef"+ + "\u0171\u02f1\u0172\u02f3\u0173\u02f5\u0174\u02f7\u0175\u02f9\u0176\u02fb"+ + "\u0177\u02fd\u0178\u02ff\u0179\u0301\u017a\u0303\u017b\u0305\u017c\u0307"+ + "\u017d\u0309\u017e\u030b\u017f\u030d\u0180\u030f\u0181\u0311\u0182\u0313"+ + "\u0183\u0315\u0184\u0317\u0185\u0319\u0186\u031b\u0187\u031d\u0188\u031f"+ + "\u0189\u0321\u018a\u0323\u018b\u0325\u018c\u0327\u018d\u0329\u018e\u032b"+ + "\u018f\u032d\u0190\u032f\u0191\u0331\u0192\u0333\u0193\u0335\u0194\u0337"+ + "\u0195\u0339\u0196\u033b\u0197\u033d\u0198\u033f\u0199\u0341\u019a\u0343"+ + "\u019b\u0345\u019c\u0347\u019d\u0349\u019e\u034b\u019f\u034d\u01a0\u034f"+ + "\u01a1\u0351\u01a2\u0353\u01a3\u0355\u01a4\u0357\u01a5\u0359\u01a6\u035b"+ + "\u01a7\u035d\u01a8\u035f\u01a9\u0361\u01aa\u0363\u01ab\u0365\u01ac\u0367"+ + "\u01ad\u0369\u01ae\u036b\u01af\u036d\u01b0\u036f\u01b1\u0371\u01b2\u0373"+ + "\u01b3\u0375\u01b4\u0377\u01b5\u0379\u01b6\u037b\u01b7\u037d\u01b8\u037f"+ + "\u01b9\u0381\u01ba\u0383\u01bb\u0385\u01bc\u0387\u01bd\u0389\u01be\u038b"+ + "\u01bf\u038d\u01c0\u038f\u01c1\u0391\u01c2\u0393\u01c3\u0395\u01c4\u0397"+ + "\u01c5\u0399\u01c6\u039b\u01c7\u039d\u01c8\u039f\u01c9\u03a1\u01ca\u03a3"+ + "\u01cb\u03a5\u01cc\u03a7\u01cd\u03a9\u01ce\u03ab\u01cf\u03ad\u01d0\u03af"+ + "\u01d1\u03b1\u01d2\u03b3\u01d3\u03b5\u01d4\u03b7\u01d5\u03b9\u01d6\u03bb"+ + "\u01d7\u03bd\u01d8\u03bf\u01d9\u03c1\u01da\u03c3\u01db\u03c5\u01dc\u03c7"+ + "\u01dd\u03c9\u01de\u03cb\u01df\u03cd\u01e0\u03cf\u01e1\u03d1\u01e2\u03d3"+ + "\u01e3\u03d5\u01e4\u03d7\u01e5\u03d9\u01e6\u03db\u01e7\u03dd\u01e8\u03df"+ + "\u01e9\u03e1\u01ea\u03e3\u01eb\u03e5\u01ec\u03e7\u01ed\u03e9\u01ee\u03eb"+ + "\u01ef\u03ed\u01f0\u03ef\u01f1\u03f1\u01f2\u03f3\u01f3\u03f5\u01f4\u03f7"+ + "\u01f5\u03f9\u01f6\u03fb\u01f7\u03fd\u01f8\u03ff\u01f9\u0401\u01fa\u0403"+ + "\u01fb\u0405\u01fc\u0407\u01fd\u0409\u01fe\u040b\u01ff\u040d\u0200\u040f"+ + "\u0201\u0411\u0202\u0413\u0203\u0415\u0204\u0417\u0205\u0419\u0206\u041b"+ + "\u0207\u041d\u0208\u041f\u0209\u0421\u020a\u0423\u020b\u0425\u020c\u0427"+ + "\u020d\u0429\u020e\u042b\u020f\u042d\u0210\u042f\u0211\u0431\u0212\u0433"+ + "\u0213\u0435\u0214\u0437\u0215\u0439\u0216\u043b\u0217\u043d\u0218\u043f"+ + "\u0219\u0441\u021a\u0443\u021b\u0445\u021c\u0447\u021d\u0449\u021e\u044b"+ + "\u021f\u044d\u0220\u044f\u0221\u0451\u0222\u0453\u0223\u0455\u0224\u0457"+ + "\u0225\u0459\u0226\u045b\u0227\u045d\u0228\u045f\u0229\u0461\u022a\u0463"+ + "\u022b\u0465\u022c\u0467\u022d\u0469\u022e\u046b\u022f\u046d\u0230\u046f"+ + "\u0231\u0471\u0232\u0473\u0233\u0475\u0234\u0477\u0235\u0479\u0236\u047b"+ + "\u0237\u047d\u0238\u047f\u0239\u0481\u023a\u0483\u023b\u0485\u023c\u0487"+ + "\u023d\u0489\u023e\u048b\u023f\u048d\u0240\u048f\u0241\u0491\u0242\u0493"+ + "\u0243\u0495\u0244\u0497\u0245\u0499\u0246\u049b\u0247\u049d\u0248\u049f"+ + "\u0249\u04a1\u024a\u04a3\u024b\u04a5\u024c\u04a7\u024d\u04a9\u024e\u04ab"+ + "\u024f\u04ad\u0250\u04af\u0251\u04b1\u0252\u04b3\u0253\u04b5\u0254\u04b7"+ + "\u0255\u04b9\u0256\u04bb\u0257\u04bd\u0258\u04bf\u0259\u04c1\u025a\u04c3"+ + "\u025b\u04c5\u025c\u04c7\u025d\u04c9\u025e\u04cb\u025f\u04cd\u0260\u04cf"+ + "\u0261\u04d1\u0262\u04d3\u0263\u04d5\u0264\u04d7\u0265\u04d9\u0266\u04db"+ + "\u0267\u04dd\u0268\u04df\u0269\u04e1\u026a\u04e3\u026b\u04e5\u026c\u04e7"+ + "\u026d\u04e9\u026e\u04eb\u026f\u04ed\u0270\u04ef\u0271\u04f1\u0272\u04f3"+ + "\u0273\u04f5\u0274\u04f7\u0275\u04f9\u0276\u04fb\u0277\u04fd\u0278\u04ff"+ + "\u0279\u0501\u027a\u0503\u027b\u0505\u027c\u0507\u027d\u0509\u027e\u050b"+ + "\u027f\u050d\u0000\u050f\u0000\u0511\u0000\u0513\u0280\u0515\u0281\u0517"+ + "\u0282\u0519\u0283\u051b\u0284\u051d\u0285\u051f\u0286\u0521\u0287\u0523"+ + "\u0288\u0525\u0289\u0527\u0000\u0529\u028a\u052b\u028b\u052d\u028c\u052f"+ + "\u0000\u0531\u028d\u0533\u028e\u0535\u028f\u0537\u0290\u0539\u0291\u053b"+ + "\u0292\u053d\u0293\u053f\u0294\u0541\u0295\u0543\u0296\u0545\u0297\u0547"+ + "\u0000\u0549\u0298\u054b\u0299\u054d\u029a\u054f\u029b\u0551\u029c\u0553"+ + "\u029d\u0555\u029e\u0557\u029f\u0559\u02a0\u055b\u02a1\u055d\u02a2\u055f"+ + "\u0000\u0561\u02a3\u0563\u02a4\u0565\u0000\u0567\u0000\u0569\u0000\u056b"+ + "\u0000\u056d\u0000\u056f\u02a7\u0571\u02a5\u0573\u02a6\u0005\u0000\u0001"+ + "\u0002\u0003\u00041\u0001\u000009\u0002\u0000++--\n\u0000!!##%&**<>@@"+ + "^^``||~~\u0002\u0000*+<>\b\u0000!!##%&@@^^``||~~\u0002\u0000AAaa\u0002"+ + "\u0000LLll\u0002\u0000NNnn\u0002\u0000YYyy\u0002\u0000SSss\u0002\u0000"+ + "EEee\u0002\u0000ZZzz\u0002\u0000DDdd\u0002\u0000RRrr\u0002\u0000CCcc\u0002"+ + "\u0000MMmm\u0002\u0000TTtt\u0002\u0000IIii\u0002\u0000BBbb\u0002\u0000"+ + "OOoo\u0002\u0000HHhh\u0002\u0000KKkk\u0002\u0000UUuu\u0002\u0000GGgg\u0002"+ + "\u0000PPpp\u0002\u0000FFff\u0002\u0000XXxx\u0002\u0000VVvv\u0002\u0000"+ + "QQqq\u0002\u0000WWww\u0002\u0000JJjj\t\u0000AZ__az\u00aa\u00aa\u00b5\u00b5"+ + "\u00ba\u00ba\u00c0\u00d6\u00d8\u00f6\u00f8\u00ff\u0002\u0000\u0100\u8000"+ + "\ud7ff\u8000\ue000\u8000\uffff\u0001\u0000\u8000\ud800\u8000\udbff\u0001"+ + "\u0000\u8000\udc00\u8000\udfff\u0002\u0000\u0000\u0000\"\"\u0001\u0000"+ + "\"\"\u0001\u0000\'\'\u0001\u000001\u0003\u000009AFaf\u0002\u0000\"\"\\"+ + "\\\u0002\u0000\t\t \u0002\u0000\n\n\r\r\u0002\u0000**//\u0004\u0000\n"+ + "\n\r\r\"\"\\\\\u0003\u0000\n\n\r\r\"\"\u0003\u0000UUuuxx\u0002\u0000\'"+ + "\'\\\\\u0001\u0000$$\u1af2\u0000\u0005\u0001\u0000\u0000\u0000\u0000\t"+ + "\u0001\u0000\u0000\u0000\u0000\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001"+ + "\u0000\u0000\u0000\u0000\u000f\u0001\u0000\u0000\u0000\u0000\u0011\u0001"+ + "\u0000\u0000\u0000\u0000\u0013\u0001\u0000\u0000\u0000\u0000\u0015\u0001"+ + "\u0000\u0000\u0000\u0000\u0017\u0001\u0000\u0000\u0000\u0000\u0019\u0001"+ + "\u0000\u0000\u0000\u0000\u001b\u0001\u0000\u0000\u0000\u0000\u001d\u0001"+ + "\u0000\u0000\u0000\u0000\u001f\u0001\u0000\u0000\u0000\u0000!\u0001\u0000"+ + "\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000%\u0001\u0000\u0000\u0000"+ + "\u0000\'\u0001\u0000\u0000\u0000\u0000)\u0001\u0000\u0000\u0000\u0000"+ + "+\u0001\u0000\u0000\u0000\u0000-\u0001\u0000\u0000\u0000\u0000/\u0001"+ + "\u0000\u0000\u0000\u00001\u0001\u0000\u0000\u0000\u00003\u0001\u0000\u0000"+ + "\u0000\u00005\u0001\u0000\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u0000"+ + "9\u0001\u0000\u0000\u0000\u0000;\u0001\u0000\u0000\u0000\u0000=\u0001"+ + "\u0000\u0000\u0000\u0000?\u0001\u0000\u0000\u0000\u0000A\u0001\u0000\u0000"+ + "\u0000\u0000C\u0001\u0000\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000"+ + "M\u0001\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000Q\u0001"+ + "\u0000\u0000\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001\u0000\u0000"+ + "\u0000\u0000W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000"+ + "[\u0001\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000_\u0001"+ + "\u0000\u0000\u0000\u0000a\u0001\u0000\u0000\u0000\u0000c\u0001\u0000\u0000"+ + "\u0000\u0000e\u0001\u0000\u0000\u0000\u0000g\u0001\u0000\u0000\u0000\u0000"+ + "i\u0001\u0000\u0000\u0000\u0000k\u0001\u0000\u0000\u0000\u0000m\u0001"+ + "\u0000\u0000\u0000\u0000o\u0001\u0000\u0000\u0000\u0000q\u0001\u0000\u0000"+ + "\u0000\u0000s\u0001\u0000\u0000\u0000\u0000u\u0001\u0000\u0000\u0000\u0000"+ + "w\u0001\u0000\u0000\u0000\u0000y\u0001\u0000\u0000\u0000\u0000{\u0001"+ + "\u0000\u0000\u0000\u0000}\u0001\u0000\u0000\u0000\u0000\u007f\u0001\u0000"+ + "\u0000\u0000\u0000\u0081\u0001\u0000\u0000\u0000\u0000\u0083\u0001\u0000"+ + "\u0000\u0000\u0000\u0085\u0001\u0000\u0000\u0000\u0000\u0087\u0001\u0000"+ + "\u0000\u0000\u0000\u0089\u0001\u0000\u0000\u0000\u0000\u008b\u0001\u0000"+ + "\u0000\u0000\u0000\u008d\u0001\u0000\u0000\u0000\u0000\u008f\u0001\u0000"+ + "\u0000\u0000\u0000\u0091\u0001\u0000\u0000\u0000\u0000\u0093\u0001\u0000"+ + "\u0000\u0000\u0000\u0095\u0001\u0000\u0000\u0000\u0000\u0097\u0001\u0000"+ + "\u0000\u0000\u0000\u0099\u0001\u0000\u0000\u0000\u0000\u009b\u0001\u0000"+ + "\u0000\u0000\u0000\u009d\u0001\u0000\u0000\u0000\u0000\u009f\u0001\u0000"+ + "\u0000\u0000\u0000\u00a1\u0001\u0000\u0000\u0000\u0000\u00a3\u0001\u0000"+ + "\u0000\u0000\u0000\u00a5\u0001\u0000\u0000\u0000\u0000\u00a7\u0001\u0000"+ + "\u0000\u0000\u0000\u00a9\u0001\u0000\u0000\u0000\u0000\u00ab\u0001\u0000"+ + "\u0000\u0000\u0000\u00ad\u0001\u0000\u0000\u0000\u0000\u00af\u0001\u0000"+ + "\u0000\u0000\u0000\u00b1\u0001\u0000\u0000\u0000\u0000\u00b3\u0001\u0000"+ + "\u0000\u0000\u0000\u00b5\u0001\u0000\u0000\u0000\u0000\u00b7\u0001\u0000"+ + "\u0000\u0000\u0000\u00b9\u0001\u0000\u0000\u0000\u0000\u00bb\u0001\u0000"+ + "\u0000\u0000\u0000\u00bd\u0001\u0000\u0000\u0000\u0000\u00bf\u0001\u0000"+ + "\u0000\u0000\u0000\u00c1\u0001\u0000\u0000\u0000\u0000\u00c3\u0001\u0000"+ + "\u0000\u0000\u0000\u00c5\u0001\u0000\u0000\u0000\u0000\u00c7\u0001\u0000"+ + "\u0000\u0000\u0000\u00c9\u0001\u0000\u0000\u0000\u0000\u00cb\u0001\u0000"+ + "\u0000\u0000\u0000\u00cd\u0001\u0000\u0000\u0000\u0000\u00cf\u0001\u0000"+ + "\u0000\u0000\u0000\u00d1\u0001\u0000\u0000\u0000\u0000\u00d3\u0001\u0000"+ + "\u0000\u0000\u0000\u00d5\u0001\u0000\u0000\u0000\u0000\u00d7\u0001\u0000"+ + "\u0000\u0000\u0000\u00d9\u0001\u0000\u0000\u0000\u0000\u00db\u0001\u0000"+ + "\u0000\u0000\u0000\u00dd\u0001\u0000\u0000\u0000\u0000\u00df\u0001\u0000"+ + "\u0000\u0000\u0000\u00e1\u0001\u0000\u0000\u0000\u0000\u00e3\u0001\u0000"+ + "\u0000\u0000\u0000\u00e5\u0001\u0000\u0000\u0000\u0000\u00e7\u0001\u0000"+ + "\u0000\u0000\u0000\u00e9\u0001\u0000\u0000\u0000\u0000\u00eb\u0001\u0000"+ + "\u0000\u0000\u0000\u00ed\u0001\u0000\u0000\u0000\u0000\u00ef\u0001\u0000"+ + "\u0000\u0000\u0000\u00f1\u0001\u0000\u0000\u0000\u0000\u00f3\u0001\u0000"+ + "\u0000\u0000\u0000\u00f5\u0001\u0000\u0000\u0000\u0000\u00f7\u0001\u0000"+ + "\u0000\u0000\u0000\u00f9\u0001\u0000\u0000\u0000\u0000\u00fb\u0001\u0000"+ + "\u0000\u0000\u0000\u00fd\u0001\u0000\u0000\u0000\u0000\u00ff\u0001\u0000"+ + "\u0000\u0000\u0000\u0101\u0001\u0000\u0000\u0000\u0000\u0103\u0001\u0000"+ + "\u0000\u0000\u0000\u0105\u0001\u0000\u0000\u0000\u0000\u0107\u0001\u0000"+ + "\u0000\u0000\u0000\u0109\u0001\u0000\u0000\u0000\u0000\u010b\u0001\u0000"+ + "\u0000\u0000\u0000\u010d\u0001\u0000\u0000\u0000\u0000\u010f\u0001\u0000"+ + "\u0000\u0000\u0000\u0111\u0001\u0000\u0000\u0000\u0000\u0113\u0001\u0000"+ + "\u0000\u0000\u0000\u0115\u0001\u0000\u0000\u0000\u0000\u0117\u0001\u0000"+ + "\u0000\u0000\u0000\u0119\u0001\u0000\u0000\u0000\u0000\u011b\u0001\u0000"+ + "\u0000\u0000\u0000\u011d\u0001\u0000\u0000\u0000\u0000\u011f\u0001\u0000"+ + "\u0000\u0000\u0000\u0121\u0001\u0000\u0000\u0000\u0000\u0123\u0001\u0000"+ + "\u0000\u0000\u0000\u0125\u0001\u0000\u0000\u0000\u0000\u0127\u0001\u0000"+ + "\u0000\u0000\u0000\u0129\u0001\u0000\u0000\u0000\u0000\u012b\u0001\u0000"+ + "\u0000\u0000\u0000\u012d\u0001\u0000\u0000\u0000\u0000\u012f\u0001\u0000"+ + "\u0000\u0000\u0000\u0131\u0001\u0000\u0000\u0000\u0000\u0133\u0001\u0000"+ + "\u0000\u0000\u0000\u0135\u0001\u0000\u0000\u0000\u0000\u0137\u0001\u0000"+ + "\u0000\u0000\u0000\u0139\u0001\u0000\u0000\u0000\u0000\u013b\u0001\u0000"+ + "\u0000\u0000\u0000\u013d\u0001\u0000\u0000\u0000\u0000\u013f\u0001\u0000"+ + "\u0000\u0000\u0000\u0141\u0001\u0000\u0000\u0000\u0000\u0143\u0001\u0000"+ + "\u0000\u0000\u0000\u0145\u0001\u0000\u0000\u0000\u0000\u0147\u0001\u0000"+ + "\u0000\u0000\u0000\u0149\u0001\u0000\u0000\u0000\u0000\u014b\u0001\u0000"+ + "\u0000\u0000\u0000\u014d\u0001\u0000\u0000\u0000\u0000\u014f\u0001\u0000"+ + "\u0000\u0000\u0000\u0151\u0001\u0000\u0000\u0000\u0000\u0153\u0001\u0000"+ + "\u0000\u0000\u0000\u0155\u0001\u0000\u0000\u0000\u0000\u0157\u0001\u0000"+ + "\u0000\u0000\u0000\u0159\u0001\u0000\u0000\u0000\u0000\u015b\u0001\u0000"+ + "\u0000\u0000\u0000\u015d\u0001\u0000\u0000\u0000\u0000\u015f\u0001\u0000"+ + "\u0000\u0000\u0000\u0161\u0001\u0000\u0000\u0000\u0000\u0163\u0001\u0000"+ + "\u0000\u0000\u0000\u0165\u0001\u0000\u0000\u0000\u0000\u0167\u0001\u0000"+ + "\u0000\u0000\u0000\u0169\u0001\u0000\u0000\u0000\u0000\u016b\u0001\u0000"+ + "\u0000\u0000\u0000\u016d\u0001\u0000\u0000\u0000\u0000\u016f\u0001\u0000"+ + "\u0000\u0000\u0000\u0171\u0001\u0000\u0000\u0000\u0000\u0173\u0001\u0000"+ + "\u0000\u0000\u0000\u0175\u0001\u0000\u0000\u0000\u0000\u0177\u0001\u0000"+ + "\u0000\u0000\u0000\u0179\u0001\u0000\u0000\u0000\u0000\u017b\u0001\u0000"+ + "\u0000\u0000\u0000\u017d\u0001\u0000\u0000\u0000\u0000\u017f\u0001\u0000"+ + "\u0000\u0000\u0000\u0181\u0001\u0000\u0000\u0000\u0000\u0183\u0001\u0000"+ + "\u0000\u0000\u0000\u0185\u0001\u0000\u0000\u0000\u0000\u0187\u0001\u0000"+ + "\u0000\u0000\u0000\u0189\u0001\u0000\u0000\u0000\u0000\u018b\u0001\u0000"+ + "\u0000\u0000\u0000\u018d\u0001\u0000\u0000\u0000\u0000\u018f\u0001\u0000"+ + "\u0000\u0000\u0000\u0191\u0001\u0000\u0000\u0000\u0000\u0193\u0001\u0000"+ + "\u0000\u0000\u0000\u0195\u0001\u0000\u0000\u0000\u0000\u0197\u0001\u0000"+ + "\u0000\u0000\u0000\u0199\u0001\u0000\u0000\u0000\u0000\u019b\u0001\u0000"+ + "\u0000\u0000\u0000\u019d\u0001\u0000\u0000\u0000\u0000\u019f\u0001\u0000"+ + "\u0000\u0000\u0000\u01a1\u0001\u0000\u0000\u0000\u0000\u01a3\u0001\u0000"+ + "\u0000\u0000\u0000\u01a5\u0001\u0000\u0000\u0000\u0000\u01a7\u0001\u0000"+ + "\u0000\u0000\u0000\u01a9\u0001\u0000\u0000\u0000\u0000\u01ab\u0001\u0000"+ + "\u0000\u0000\u0000\u01ad\u0001\u0000\u0000\u0000\u0000\u01af\u0001\u0000"+ + "\u0000\u0000\u0000\u01b1\u0001\u0000\u0000\u0000\u0000\u01b3\u0001\u0000"+ + "\u0000\u0000\u0000\u01b5\u0001\u0000\u0000\u0000\u0000\u01b7\u0001\u0000"+ + "\u0000\u0000\u0000\u01b9\u0001\u0000\u0000\u0000\u0000\u01bb\u0001\u0000"+ + "\u0000\u0000\u0000\u01bd\u0001\u0000\u0000\u0000\u0000\u01bf\u0001\u0000"+ + "\u0000\u0000\u0000\u01c1\u0001\u0000\u0000\u0000\u0000\u01c3\u0001\u0000"+ + "\u0000\u0000\u0000\u01c5\u0001\u0000\u0000\u0000\u0000\u01c7\u0001\u0000"+ + "\u0000\u0000\u0000\u01c9\u0001\u0000\u0000\u0000\u0000\u01cb\u0001\u0000"+ + "\u0000\u0000\u0000\u01cd\u0001\u0000\u0000\u0000\u0000\u01cf\u0001\u0000"+ + "\u0000\u0000\u0000\u01d1\u0001\u0000\u0000\u0000\u0000\u01d3\u0001\u0000"+ + "\u0000\u0000\u0000\u01d5\u0001\u0000\u0000\u0000\u0000\u01d7\u0001\u0000"+ + "\u0000\u0000\u0000\u01d9\u0001\u0000\u0000\u0000\u0000\u01db\u0001\u0000"+ + "\u0000\u0000\u0000\u01dd\u0001\u0000\u0000\u0000\u0000\u01df\u0001\u0000"+ + "\u0000\u0000\u0000\u01e1\u0001\u0000\u0000\u0000\u0000\u01e3\u0001\u0000"+ + "\u0000\u0000\u0000\u01e5\u0001\u0000\u0000\u0000\u0000\u01e7\u0001\u0000"+ + "\u0000\u0000\u0000\u01e9\u0001\u0000\u0000\u0000\u0000\u01eb\u0001\u0000"+ + "\u0000\u0000\u0000\u01ed\u0001\u0000\u0000\u0000\u0000\u01ef\u0001\u0000"+ + "\u0000\u0000\u0000\u01f1\u0001\u0000\u0000\u0000\u0000\u01f3\u0001\u0000"+ + "\u0000\u0000\u0000\u01f5\u0001\u0000\u0000\u0000\u0000\u01f7\u0001\u0000"+ + "\u0000\u0000\u0000\u01f9\u0001\u0000\u0000\u0000\u0000\u01fb\u0001\u0000"+ + "\u0000\u0000\u0000\u01fd\u0001\u0000\u0000\u0000\u0000\u01ff\u0001\u0000"+ + "\u0000\u0000\u0000\u0201\u0001\u0000\u0000\u0000\u0000\u0203\u0001\u0000"+ + "\u0000\u0000\u0000\u0205\u0001\u0000\u0000\u0000\u0000\u0207\u0001\u0000"+ + "\u0000\u0000\u0000\u0209\u0001\u0000\u0000\u0000\u0000\u020b\u0001\u0000"+ + "\u0000\u0000\u0000\u020d\u0001\u0000\u0000\u0000\u0000\u020f\u0001\u0000"+ + "\u0000\u0000\u0000\u0211\u0001\u0000\u0000\u0000\u0000\u0213\u0001\u0000"+ + "\u0000\u0000\u0000\u0215\u0001\u0000\u0000\u0000\u0000\u0217\u0001\u0000"+ + "\u0000\u0000\u0000\u0219\u0001\u0000\u0000\u0000\u0000\u021b\u0001\u0000"+ + "\u0000\u0000\u0000\u021d\u0001\u0000\u0000\u0000\u0000\u021f\u0001\u0000"+ + "\u0000\u0000\u0000\u0221\u0001\u0000\u0000\u0000\u0000\u0223\u0001\u0000"+ + "\u0000\u0000\u0000\u0225\u0001\u0000\u0000\u0000\u0000\u0227\u0001\u0000"+ + "\u0000\u0000\u0000\u0229\u0001\u0000\u0000\u0000\u0000\u022b\u0001\u0000"+ + "\u0000\u0000\u0000\u022d\u0001\u0000\u0000\u0000\u0000\u022f\u0001\u0000"+ + "\u0000\u0000\u0000\u0231\u0001\u0000\u0000\u0000\u0000\u0233\u0001\u0000"+ + "\u0000\u0000\u0000\u0235\u0001\u0000\u0000\u0000\u0000\u0237\u0001\u0000"+ + "\u0000\u0000\u0000\u0239\u0001\u0000\u0000\u0000\u0000\u023b\u0001\u0000"+ + "\u0000\u0000\u0000\u023d\u0001\u0000\u0000\u0000\u0000\u023f\u0001\u0000"+ + "\u0000\u0000\u0000\u0241\u0001\u0000\u0000\u0000\u0000\u0243\u0001\u0000"+ + "\u0000\u0000\u0000\u0245\u0001\u0000\u0000\u0000\u0000\u0247\u0001\u0000"+ + "\u0000\u0000\u0000\u0249\u0001\u0000\u0000\u0000\u0000\u024b\u0001\u0000"+ + "\u0000\u0000\u0000\u024d\u0001\u0000\u0000\u0000\u0000\u024f\u0001\u0000"+ + "\u0000\u0000\u0000\u0251\u0001\u0000\u0000\u0000\u0000\u0253\u0001\u0000"+ + "\u0000\u0000\u0000\u0255\u0001\u0000\u0000\u0000\u0000\u0257\u0001\u0000"+ + "\u0000\u0000\u0000\u0259\u0001\u0000\u0000\u0000\u0000\u025b\u0001\u0000"+ + "\u0000\u0000\u0000\u025d\u0001\u0000\u0000\u0000\u0000\u025f\u0001\u0000"+ + "\u0000\u0000\u0000\u0261\u0001\u0000\u0000\u0000\u0000\u0263\u0001\u0000"+ + "\u0000\u0000\u0000\u0265\u0001\u0000\u0000\u0000\u0000\u0267\u0001\u0000"+ + "\u0000\u0000\u0000\u0269\u0001\u0000\u0000\u0000\u0000\u026b\u0001\u0000"+ + "\u0000\u0000\u0000\u026d\u0001\u0000\u0000\u0000\u0000\u026f\u0001\u0000"+ + "\u0000\u0000\u0000\u0271\u0001\u0000\u0000\u0000\u0000\u0273\u0001\u0000"+ + "\u0000\u0000\u0000\u0275\u0001\u0000\u0000\u0000\u0000\u0277\u0001\u0000"+ + "\u0000\u0000\u0000\u0279\u0001\u0000\u0000\u0000\u0000\u027b\u0001\u0000"+ + "\u0000\u0000\u0000\u027d\u0001\u0000\u0000\u0000\u0000\u027f\u0001\u0000"+ + "\u0000\u0000\u0000\u0281\u0001\u0000\u0000\u0000\u0000\u0283\u0001\u0000"+ + "\u0000\u0000\u0000\u0285\u0001\u0000\u0000\u0000\u0000\u0287\u0001\u0000"+ + "\u0000\u0000\u0000\u0289\u0001\u0000\u0000\u0000\u0000\u028b\u0001\u0000"+ + "\u0000\u0000\u0000\u028d\u0001\u0000\u0000\u0000\u0000\u028f\u0001\u0000"+ + "\u0000\u0000\u0000\u0291\u0001\u0000\u0000\u0000\u0000\u0293\u0001\u0000"+ + "\u0000\u0000\u0000\u0295\u0001\u0000\u0000\u0000\u0000\u0297\u0001\u0000"+ + "\u0000\u0000\u0000\u0299\u0001\u0000\u0000\u0000\u0000\u029b\u0001\u0000"+ + "\u0000\u0000\u0000\u029d\u0001\u0000\u0000\u0000\u0000\u029f\u0001\u0000"+ + "\u0000\u0000\u0000\u02a1\u0001\u0000\u0000\u0000\u0000\u02a3\u0001\u0000"+ + "\u0000\u0000\u0000\u02a5\u0001\u0000\u0000\u0000\u0000\u02a7\u0001\u0000"+ + "\u0000\u0000\u0000\u02a9\u0001\u0000\u0000\u0000\u0000\u02ab\u0001\u0000"+ + "\u0000\u0000\u0000\u02ad\u0001\u0000\u0000\u0000\u0000\u02af\u0001\u0000"+ + "\u0000\u0000\u0000\u02b1\u0001\u0000\u0000\u0000\u0000\u02b3\u0001\u0000"+ + "\u0000\u0000\u0000\u02b5\u0001\u0000\u0000\u0000\u0000\u02b7\u0001\u0000"+ + "\u0000\u0000\u0000\u02b9\u0001\u0000\u0000\u0000\u0000\u02bb\u0001\u0000"+ + "\u0000\u0000\u0000\u02bd\u0001\u0000\u0000\u0000\u0000\u02bf\u0001\u0000"+ + "\u0000\u0000\u0000\u02c1\u0001\u0000\u0000\u0000\u0000\u02c3\u0001\u0000"+ + "\u0000\u0000\u0000\u02c5\u0001\u0000\u0000\u0000\u0000\u02c7\u0001\u0000"+ + "\u0000\u0000\u0000\u02c9\u0001\u0000\u0000\u0000\u0000\u02cb\u0001\u0000"+ + "\u0000\u0000\u0000\u02cd\u0001\u0000\u0000\u0000\u0000\u02cf\u0001\u0000"+ + "\u0000\u0000\u0000\u02d1\u0001\u0000\u0000\u0000\u0000\u02d3\u0001\u0000"+ + "\u0000\u0000\u0000\u02d5\u0001\u0000\u0000\u0000\u0000\u02d7\u0001\u0000"+ + "\u0000\u0000\u0000\u02d9\u0001\u0000\u0000\u0000\u0000\u02db\u0001\u0000"+ + "\u0000\u0000\u0000\u02dd\u0001\u0000\u0000\u0000\u0000\u02df\u0001\u0000"+ + "\u0000\u0000\u0000\u02e1\u0001\u0000\u0000\u0000\u0000\u02e3\u0001\u0000"+ + "\u0000\u0000\u0000\u02e5\u0001\u0000\u0000\u0000\u0000\u02e7\u0001\u0000"+ + "\u0000\u0000\u0000\u02e9\u0001\u0000\u0000\u0000\u0000\u02eb\u0001\u0000"+ + "\u0000\u0000\u0000\u02ed\u0001\u0000\u0000\u0000\u0000\u02ef\u0001\u0000"+ + "\u0000\u0000\u0000\u02f1\u0001\u0000\u0000\u0000\u0000\u02f3\u0001\u0000"+ + "\u0000\u0000\u0000\u02f5\u0001\u0000\u0000\u0000\u0000\u02f7\u0001\u0000"+ + "\u0000\u0000\u0000\u02f9\u0001\u0000\u0000\u0000\u0000\u02fb\u0001\u0000"+ + "\u0000\u0000\u0000\u02fd\u0001\u0000\u0000\u0000\u0000\u02ff\u0001\u0000"+ + "\u0000\u0000\u0000\u0301\u0001\u0000\u0000\u0000\u0000\u0303\u0001\u0000"+ + "\u0000\u0000\u0000\u0305\u0001\u0000\u0000\u0000\u0000\u0307\u0001\u0000"+ + "\u0000\u0000\u0000\u0309\u0001\u0000\u0000\u0000\u0000\u030b\u0001\u0000"+ + "\u0000\u0000\u0000\u030d\u0001\u0000\u0000\u0000\u0000\u030f\u0001\u0000"+ + "\u0000\u0000\u0000\u0311\u0001\u0000\u0000\u0000\u0000\u0313\u0001\u0000"+ + "\u0000\u0000\u0000\u0315\u0001\u0000\u0000\u0000\u0000\u0317\u0001\u0000"+ + "\u0000\u0000\u0000\u0319\u0001\u0000\u0000\u0000\u0000\u031b\u0001\u0000"+ + "\u0000\u0000\u0000\u031d\u0001\u0000\u0000\u0000\u0000\u031f\u0001\u0000"+ + "\u0000\u0000\u0000\u0321\u0001\u0000\u0000\u0000\u0000\u0323\u0001\u0000"+ + "\u0000\u0000\u0000\u0325\u0001\u0000\u0000\u0000\u0000\u0327\u0001\u0000"+ + "\u0000\u0000\u0000\u0329\u0001\u0000\u0000\u0000\u0000\u032b\u0001\u0000"+ + "\u0000\u0000\u0000\u032d\u0001\u0000\u0000\u0000\u0000\u032f\u0001\u0000"+ + "\u0000\u0000\u0000\u0331\u0001\u0000\u0000\u0000\u0000\u0333\u0001\u0000"+ + "\u0000\u0000\u0000\u0335\u0001\u0000\u0000\u0000\u0000\u0337\u0001\u0000"+ + "\u0000\u0000\u0000\u0339\u0001\u0000\u0000\u0000\u0000\u033b\u0001\u0000"+ + "\u0000\u0000\u0000\u033d\u0001\u0000\u0000\u0000\u0000\u033f\u0001\u0000"+ + "\u0000\u0000\u0000\u0341\u0001\u0000\u0000\u0000\u0000\u0343\u0001\u0000"+ + "\u0000\u0000\u0000\u0345\u0001\u0000\u0000\u0000\u0000\u0347\u0001\u0000"+ + "\u0000\u0000\u0000\u0349\u0001\u0000\u0000\u0000\u0000\u034b\u0001\u0000"+ + "\u0000\u0000\u0000\u034d\u0001\u0000\u0000\u0000\u0000\u034f\u0001\u0000"+ + "\u0000\u0000\u0000\u0351\u0001\u0000\u0000\u0000\u0000\u0353\u0001\u0000"+ + "\u0000\u0000\u0000\u0355\u0001\u0000\u0000\u0000\u0000\u0357\u0001\u0000"+ + "\u0000\u0000\u0000\u0359\u0001\u0000\u0000\u0000\u0000\u035b\u0001\u0000"+ + "\u0000\u0000\u0000\u035d\u0001\u0000\u0000\u0000\u0000\u035f\u0001\u0000"+ + "\u0000\u0000\u0000\u0361\u0001\u0000\u0000\u0000\u0000\u0363\u0001\u0000"+ + "\u0000\u0000\u0000\u0365\u0001\u0000\u0000\u0000\u0000\u0367\u0001\u0000"+ + "\u0000\u0000\u0000\u0369\u0001\u0000\u0000\u0000\u0000\u036b\u0001\u0000"+ + "\u0000\u0000\u0000\u036d\u0001\u0000\u0000\u0000\u0000\u036f\u0001\u0000"+ + "\u0000\u0000\u0000\u0371\u0001\u0000\u0000\u0000\u0000\u0373\u0001\u0000"+ + "\u0000\u0000\u0000\u0375\u0001\u0000\u0000\u0000\u0000\u0377\u0001\u0000"+ + "\u0000\u0000\u0000\u0379\u0001\u0000\u0000\u0000\u0000\u037b\u0001\u0000"+ + "\u0000\u0000\u0000\u037d\u0001\u0000\u0000\u0000\u0000\u037f\u0001\u0000"+ + "\u0000\u0000\u0000\u0381\u0001\u0000\u0000\u0000\u0000\u0383\u0001\u0000"+ + "\u0000\u0000\u0000\u0385\u0001\u0000\u0000\u0000\u0000\u0387\u0001\u0000"+ + "\u0000\u0000\u0000\u0389\u0001\u0000\u0000\u0000\u0000\u038b\u0001\u0000"+ + "\u0000\u0000\u0000\u038d\u0001\u0000\u0000\u0000\u0000\u038f\u0001\u0000"+ + "\u0000\u0000\u0000\u0391\u0001\u0000\u0000\u0000\u0000\u0393\u0001\u0000"+ + "\u0000\u0000\u0000\u0395\u0001\u0000\u0000\u0000\u0000\u0397\u0001\u0000"+ + "\u0000\u0000\u0000\u0399\u0001\u0000\u0000\u0000\u0000\u039b\u0001\u0000"+ + "\u0000\u0000\u0000\u039d\u0001\u0000\u0000\u0000\u0000\u039f\u0001\u0000"+ + "\u0000\u0000\u0000\u03a1\u0001\u0000\u0000\u0000\u0000\u03a3\u0001\u0000"+ + "\u0000\u0000\u0000\u03a5\u0001\u0000\u0000\u0000\u0000\u03a7\u0001\u0000"+ + "\u0000\u0000\u0000\u03a9\u0001\u0000\u0000\u0000\u0000\u03ab\u0001\u0000"+ + "\u0000\u0000\u0000\u03ad\u0001\u0000\u0000\u0000\u0000\u03af\u0001\u0000"+ + "\u0000\u0000\u0000\u03b1\u0001\u0000\u0000\u0000\u0000\u03b3\u0001\u0000"+ + "\u0000\u0000\u0000\u03b5\u0001\u0000\u0000\u0000\u0000\u03b7\u0001\u0000"+ + "\u0000\u0000\u0000\u03b9\u0001\u0000\u0000\u0000\u0000\u03bb\u0001\u0000"+ + "\u0000\u0000\u0000\u03bd\u0001\u0000\u0000\u0000\u0000\u03bf\u0001\u0000"+ + "\u0000\u0000\u0000\u03c1\u0001\u0000\u0000\u0000\u0000\u03c3\u0001\u0000"+ + "\u0000\u0000\u0000\u03c5\u0001\u0000\u0000\u0000\u0000\u03c7\u0001\u0000"+ + "\u0000\u0000\u0000\u03c9\u0001\u0000\u0000\u0000\u0000\u03cb\u0001\u0000"+ + "\u0000\u0000\u0000\u03cd\u0001\u0000\u0000\u0000\u0000\u03cf\u0001\u0000"+ + "\u0000\u0000\u0000\u03d1\u0001\u0000\u0000\u0000\u0000\u03d3\u0001\u0000"+ + "\u0000\u0000\u0000\u03d5\u0001\u0000\u0000\u0000\u0000\u03d7\u0001\u0000"+ + "\u0000\u0000\u0000\u03d9\u0001\u0000\u0000\u0000\u0000\u03db\u0001\u0000"+ + "\u0000\u0000\u0000\u03dd\u0001\u0000\u0000\u0000\u0000\u03df\u0001\u0000"+ + "\u0000\u0000\u0000\u03e1\u0001\u0000\u0000\u0000\u0000\u03e3\u0001\u0000"+ + "\u0000\u0000\u0000\u03e5\u0001\u0000\u0000\u0000\u0000\u03e7\u0001\u0000"+ + "\u0000\u0000\u0000\u03e9\u0001\u0000\u0000\u0000\u0000\u03eb\u0001\u0000"+ + "\u0000\u0000\u0000\u03ed\u0001\u0000\u0000\u0000\u0000\u03ef\u0001\u0000"+ + "\u0000\u0000\u0000\u03f1\u0001\u0000\u0000\u0000\u0000\u03f3\u0001\u0000"+ + "\u0000\u0000\u0000\u03f5\u0001\u0000\u0000\u0000\u0000\u03f7\u0001\u0000"+ + "\u0000\u0000\u0000\u03f9\u0001\u0000\u0000\u0000\u0000\u03fb\u0001\u0000"+ + "\u0000\u0000\u0000\u03fd\u0001\u0000\u0000\u0000\u0000\u03ff\u0001\u0000"+ + "\u0000\u0000\u0000\u0401\u0001\u0000\u0000\u0000\u0000\u0403\u0001\u0000"+ + "\u0000\u0000\u0000\u0405\u0001\u0000\u0000\u0000\u0000\u0407\u0001\u0000"+ + "\u0000\u0000\u0000\u0409\u0001\u0000\u0000\u0000\u0000\u040b\u0001\u0000"+ + "\u0000\u0000\u0000\u040d\u0001\u0000\u0000\u0000\u0000\u040f\u0001\u0000"+ + "\u0000\u0000\u0000\u0411\u0001\u0000\u0000\u0000\u0000\u0413\u0001\u0000"+ + "\u0000\u0000\u0000\u0415\u0001\u0000\u0000\u0000\u0000\u0417\u0001\u0000"+ + "\u0000\u0000\u0000\u0419\u0001\u0000\u0000\u0000\u0000\u041b\u0001\u0000"+ + "\u0000\u0000\u0000\u041d\u0001\u0000\u0000\u0000\u0000\u041f\u0001\u0000"+ + "\u0000\u0000\u0000\u0421\u0001\u0000\u0000\u0000\u0000\u0423\u0001\u0000"+ + "\u0000\u0000\u0000\u0425\u0001\u0000\u0000\u0000\u0000\u0427\u0001\u0000"+ + "\u0000\u0000\u0000\u0429\u0001\u0000\u0000\u0000\u0000\u042b\u0001\u0000"+ + "\u0000\u0000\u0000\u042d\u0001\u0000\u0000\u0000\u0000\u042f\u0001\u0000"+ + "\u0000\u0000\u0000\u0431\u0001\u0000\u0000\u0000\u0000\u0433\u0001\u0000"+ + "\u0000\u0000\u0000\u0435\u0001\u0000\u0000\u0000\u0000\u0437\u0001\u0000"+ + "\u0000\u0000\u0000\u0439\u0001\u0000\u0000\u0000\u0000\u043b\u0001\u0000"+ + "\u0000\u0000\u0000\u043d\u0001\u0000\u0000\u0000\u0000\u043f\u0001\u0000"+ + "\u0000\u0000\u0000\u0441\u0001\u0000\u0000\u0000\u0000\u0443\u0001\u0000"+ + "\u0000\u0000\u0000\u0445\u0001\u0000\u0000\u0000\u0000\u0447\u0001\u0000"+ + "\u0000\u0000\u0000\u0449\u0001\u0000\u0000\u0000\u0000\u044b\u0001\u0000"+ + "\u0000\u0000\u0000\u044d\u0001\u0000\u0000\u0000\u0000\u044f\u0001\u0000"+ + "\u0000\u0000\u0000\u0451\u0001\u0000\u0000\u0000\u0000\u0453\u0001\u0000"+ + "\u0000\u0000\u0000\u0455\u0001\u0000\u0000\u0000\u0000\u0457\u0001\u0000"+ + "\u0000\u0000\u0000\u0459\u0001\u0000\u0000\u0000\u0000\u045b\u0001\u0000"+ + "\u0000\u0000\u0000\u045d\u0001\u0000\u0000\u0000\u0000\u045f\u0001\u0000"+ + "\u0000\u0000\u0000\u0461\u0001\u0000\u0000\u0000\u0000\u0463\u0001\u0000"+ + "\u0000\u0000\u0000\u0465\u0001\u0000\u0000\u0000\u0000\u0467\u0001\u0000"+ + "\u0000\u0000\u0000\u0469\u0001\u0000\u0000\u0000\u0000\u046b\u0001\u0000"+ + "\u0000\u0000\u0000\u046d\u0001\u0000\u0000\u0000\u0000\u046f\u0001\u0000"+ + "\u0000\u0000\u0000\u0471\u0001\u0000\u0000\u0000\u0000\u0473\u0001\u0000"+ + "\u0000\u0000\u0000\u0475\u0001\u0000\u0000\u0000\u0000\u0477\u0001\u0000"+ + "\u0000\u0000\u0000\u0479\u0001\u0000\u0000\u0000\u0000\u047b\u0001\u0000"+ + "\u0000\u0000\u0000\u047d\u0001\u0000\u0000\u0000\u0000\u047f\u0001\u0000"+ + "\u0000\u0000\u0000\u0481\u0001\u0000\u0000\u0000\u0000\u0483\u0001\u0000"+ + "\u0000\u0000\u0000\u0485\u0001\u0000\u0000\u0000\u0000\u0487\u0001\u0000"+ + "\u0000\u0000\u0000\u0489\u0001\u0000\u0000\u0000\u0000\u048b\u0001\u0000"+ + "\u0000\u0000\u0000\u048d\u0001\u0000\u0000\u0000\u0000\u048f\u0001\u0000"+ + "\u0000\u0000\u0000\u0491\u0001\u0000\u0000\u0000\u0000\u0493\u0001\u0000"+ + "\u0000\u0000\u0000\u0495\u0001\u0000\u0000\u0000\u0000\u0497\u0001\u0000"+ + "\u0000\u0000\u0000\u0499\u0001\u0000\u0000\u0000\u0000\u049b\u0001\u0000"+ + "\u0000\u0000\u0000\u049d\u0001\u0000\u0000\u0000\u0000\u049f\u0001\u0000"+ + "\u0000\u0000\u0000\u04a1\u0001\u0000\u0000\u0000\u0000\u04a3\u0001\u0000"+ + "\u0000\u0000\u0000\u04a5\u0001\u0000\u0000\u0000\u0000\u04a7\u0001\u0000"+ + "\u0000\u0000\u0000\u04a9\u0001\u0000\u0000\u0000\u0000\u04ab\u0001\u0000"+ + "\u0000\u0000\u0000\u04ad\u0001\u0000\u0000\u0000\u0000\u04af\u0001\u0000"+ + "\u0000\u0000\u0000\u04b1\u0001\u0000\u0000\u0000\u0000\u04b3\u0001\u0000"+ + "\u0000\u0000\u0000\u04b5\u0001\u0000\u0000\u0000\u0000\u04b7\u0001\u0000"+ + "\u0000\u0000\u0000\u04b9\u0001\u0000\u0000\u0000\u0000\u04bb\u0001\u0000"+ + "\u0000\u0000\u0000\u04bd\u0001\u0000\u0000\u0000\u0000\u04bf\u0001\u0000"+ + "\u0000\u0000\u0000\u04c1\u0001\u0000\u0000\u0000\u0000\u04c3\u0001\u0000"+ + "\u0000\u0000\u0000\u04c5\u0001\u0000\u0000\u0000\u0000\u04c7\u0001\u0000"+ + "\u0000\u0000\u0000\u04c9\u0001\u0000\u0000\u0000\u0000\u04cb\u0001\u0000"+ + "\u0000\u0000\u0000\u04cd\u0001\u0000\u0000\u0000\u0000\u04cf\u0001\u0000"+ + "\u0000\u0000\u0000\u04d1\u0001\u0000\u0000\u0000\u0000\u04d3\u0001\u0000"+ + "\u0000\u0000\u0000\u04d5\u0001\u0000\u0000\u0000\u0000\u04d7\u0001\u0000"+ + "\u0000\u0000\u0000\u04d9\u0001\u0000\u0000\u0000\u0000\u04db\u0001\u0000"+ + "\u0000\u0000\u0000\u04dd\u0001\u0000\u0000\u0000\u0000\u04df\u0001\u0000"+ + "\u0000\u0000\u0000\u04e1\u0001\u0000\u0000\u0000\u0000\u04e3\u0001\u0000"+ + "\u0000\u0000\u0000\u04e5\u0001\u0000\u0000\u0000\u0000\u04e7\u0001\u0000"+ + "\u0000\u0000\u0000\u04e9\u0001\u0000\u0000\u0000\u0000\u04eb\u0001\u0000"+ + "\u0000\u0000\u0000\u04ed\u0001\u0000\u0000\u0000\u0000\u04ef\u0001\u0000"+ + "\u0000\u0000\u0000\u04f1\u0001\u0000\u0000\u0000\u0000\u04f3\u0001\u0000"+ + "\u0000\u0000\u0000\u04f5\u0001\u0000\u0000\u0000\u0000\u04f7\u0001\u0000"+ + "\u0000\u0000\u0000\u04f9\u0001\u0000\u0000\u0000\u0000\u04fb\u0001\u0000"+ + "\u0000\u0000\u0000\u04fd\u0001\u0000\u0000\u0000\u0000\u04ff\u0001\u0000"+ + "\u0000\u0000\u0000\u0501\u0001\u0000\u0000\u0000\u0000\u0503\u0001\u0000"+ + "\u0000\u0000\u0000\u0505\u0001\u0000\u0000\u0000\u0000\u0507\u0001\u0000"+ + "\u0000\u0000\u0000\u0509\u0001\u0000\u0000\u0000\u0000\u050b\u0001\u0000"+ + "\u0000\u0000\u0000\u0513\u0001\u0000\u0000\u0000\u0000\u0515\u0001\u0000"+ + "\u0000\u0000\u0000\u0517\u0001\u0000\u0000\u0000\u0000\u0519\u0001\u0000"+ + "\u0000\u0000\u0000\u051b\u0001\u0000\u0000\u0000\u0000\u051d\u0001\u0000"+ + "\u0000\u0000\u0000\u051f\u0001\u0000\u0000\u0000\u0000\u0521\u0001\u0000"+ + "\u0000\u0000\u0000\u0523\u0001\u0000\u0000\u0000\u0000\u0525\u0001\u0000"+ + "\u0000\u0000\u0000\u0527\u0001\u0000\u0000\u0000\u0000\u0529\u0001\u0000"+ + "\u0000\u0000\u0000\u052b\u0001\u0000\u0000\u0000\u0000\u052d\u0001\u0000"+ + "\u0000\u0000\u0000\u0531\u0001\u0000\u0000\u0000\u0000\u0533\u0001\u0000"+ + "\u0000\u0000\u0000\u0535\u0001\u0000\u0000\u0000\u0000\u0537\u0001\u0000"+ + "\u0000\u0000\u0000\u0539\u0001\u0000\u0000\u0000\u0000\u053b\u0001\u0000"+ + "\u0000\u0000\u0000\u053d\u0001\u0000\u0000\u0000\u0000\u053f\u0001\u0000"+ + "\u0000\u0000\u0000\u0541\u0001\u0000\u0000\u0000\u0000\u0543\u0001\u0000"+ + "\u0000\u0000\u0000\u0545\u0001\u0000\u0000\u0000\u0000\u0549\u0001\u0000"+ + "\u0000\u0000\u0000\u054b\u0001\u0000\u0000\u0000\u0000\u054d\u0001\u0000"+ + "\u0000\u0000\u0000\u054f\u0001\u0000\u0000\u0000\u0000\u0551\u0001\u0000"+ + "\u0000\u0000\u0000\u0553\u0001\u0000\u0000\u0000\u0000\u0555\u0001\u0000"+ + "\u0000\u0000\u0000\u0557\u0001\u0000\u0000\u0000\u0000\u0559\u0001\u0000"+ + "\u0000\u0000\u0001\u055b\u0001\u0000\u0000\u0000\u0001\u055d\u0001\u0000"+ + "\u0000\u0000\u0001\u0561\u0001\u0000\u0000\u0000\u0001\u0563\u0001\u0000"+ + "\u0000\u0000\u0002\u0567\u0001\u0000\u0000\u0000\u0002\u0569\u0001\u0000"+ + "\u0000\u0000\u0003\u056b\u0001\u0000\u0000\u0000\u0003\u056d\u0001\u0000"+ + "\u0000\u0000\u0003\u056f\u0001\u0000\u0000\u0000\u0004\u0571\u0001\u0000"+ + "\u0000\u0000\u0004\u0573\u0001\u0000\u0000\u0000\u0005\u0575\u0001\u0000"+ + "\u0000\u0000\u0007\u057e\u0001\u0000\u0000\u0000\t\u0581\u0001\u0000\u0000"+ + "\u0000\u000b\u0583\u0001\u0000\u0000\u0000\r\u0585\u0001\u0000\u0000\u0000"+ + "\u000f\u0587\u0001\u0000\u0000\u0000\u0011\u0589\u0001\u0000\u0000\u0000"+ + "\u0013\u058b\u0001\u0000\u0000\u0000\u0015\u058d\u0001\u0000\u0000\u0000"+ + "\u0017\u058f\u0001\u0000\u0000\u0000\u0019\u0591\u0001\u0000\u0000\u0000"+ + "\u001b\u0593\u0001\u0000\u0000\u0000\u001d\u0595\u0001\u0000\u0000\u0000"+ + "\u001f\u0597\u0001\u0000\u0000\u0000!\u0599\u0001\u0000\u0000\u0000#\u059b"+ + "\u0001\u0000\u0000\u0000%\u059d\u0001\u0000\u0000\u0000\'\u059f\u0001"+ + "\u0000\u0000\u0000)\u05a1\u0001\u0000\u0000\u0000+\u05a3\u0001\u0000\u0000"+ + "\u0000-\u05a5\u0001\u0000\u0000\u0000/\u05a8\u0001\u0000\u0000\u00001"+ + "\u05ab\u0001\u0000\u0000\u00003\u05ae\u0001\u0000\u0000\u00005\u05b1\u0001"+ + "\u0000\u0000\u00007\u05b4\u0001\u0000\u0000\u00009\u05b7\u0001\u0000\u0000"+ + "\u0000;\u05ba\u0001\u0000\u0000\u0000=\u05bd\u0001\u0000\u0000\u0000?"+ + "\u05c0\u0001\u0000\u0000\u0000A\u05c2\u0001\u0000\u0000\u0000C\u05ed\u0001"+ + "\u0000\u0000\u0000E\u05f8\u0001\u0000\u0000\u0000G\u0608\u0001\u0000\u0000"+ + "\u0000I\u060a\u0001\u0000\u0000\u0000K\u060c\u0001\u0000\u0000\u0000M"+ + "\u060e\u0001\u0000\u0000\u0000O\u0612\u0001\u0000\u0000\u0000Q\u061a\u0001"+ + "\u0000\u0000\u0000S\u0622\u0001\u0000\u0000\u0000U\u0626\u0001\u0000\u0000"+ + "\u0000W\u062a\u0001\u0000\u0000\u0000Y\u0630\u0001\u0000\u0000\u0000["+ + "\u0633\u0001\u0000\u0000\u0000]\u0637\u0001\u0000\u0000\u0000_\u0642\u0001"+ + "\u0000\u0000\u0000a\u0647\u0001\u0000\u0000\u0000c\u064c\u0001\u0000\u0000"+ + "\u0000e\u0651\u0001\u0000\u0000\u0000g\u0657\u0001\u0000\u0000\u0000i"+ + "\u065f\u0001\u0000\u0000\u0000k\u0666\u0001\u0000\u0000\u0000m\u0671\u0001"+ + "\u0000\u0000\u0000o\u0678\u0001\u0000\u0000\u0000q\u0688\u0001\u0000\u0000"+ + "\u0000s\u0695\u0001\u0000\u0000\u0000u\u06a2\u0001\u0000\u0000\u0000w"+ + "\u06af\u0001\u0000\u0000\u0000y\u06c1\u0001\u0000\u0000\u0000{\u06ce\u0001"+ + "\u0000\u0000\u0000}\u06d6\u0001\u0000\u0000\u0000\u007f\u06e1\u0001\u0000"+ + "\u0000\u0000\u0081\u06e6\u0001\u0000\u0000\u0000\u0083\u06ef\u0001\u0000"+ + "\u0000\u0000\u0085\u06f2\u0001\u0000\u0000\u0000\u0087\u06f7\u0001\u0000"+ + "\u0000\u0000\u0089\u06fe\u0001\u0000\u0000\u0000\u008b\u0704\u0001\u0000"+ + "\u0000\u0000\u008d\u070a\u0001\u0000\u0000\u0000\u008f\u070e\u0001\u0000"+ + "\u0000\u0000\u0091\u0716\u0001\u0000\u0000\u0000\u0093\u071b\u0001\u0000"+ + "\u0000\u0000\u0095\u0721\u0001\u0000\u0000\u0000\u0097\u0727\u0001\u0000"+ + "\u0000\u0000\u0099\u072e\u0001\u0000\u0000\u0000\u009b\u0731\u0001\u0000"+ + "\u0000\u0000\u009d\u073b\u0001\u0000\u0000\u0000\u009f\u0745\u0001\u0000"+ + "\u0000\u0000\u00a1\u074a\u0001\u0000\u0000\u0000\u00a3\u0752\u0001\u0000"+ + "\u0000\u0000\u00a5\u075a\u0001\u0000\u0000\u0000\u00a7\u0760\u0001\u0000"+ + "\u0000\u0000\u00a9\u076a\u0001\u0000\u0000\u0000\u00ab\u0779\u0001\u0000"+ + "\u0000\u0000\u00ad\u077d\u0001\u0000\u0000\u0000\u00af\u0782\u0001\u0000"+ + "\u0000\u0000\u00b1\u0789\u0001\u0000\u0000\u0000\u00b3\u078c\u0001\u0000"+ + "\u0000\u0000\u00b5\u0791\u0001\u0000\u0000\u0000\u00b7\u0794\u0001\u0000"+ + "\u0000\u0000\u00b9\u079a\u0001\u0000\u0000\u0000\u00bb\u07a2\u0001\u0000"+ + "\u0000\u0000\u00bd\u07aa\u0001\u0000\u0000\u0000\u00bf\u07b5\u0001\u0000"+ + "\u0000\u0000\u00c1\u07bf\u0001\u0000\u0000\u0000\u00c3\u07c6\u0001\u0000"+ + "\u0000\u0000\u00c5\u07d3\u0001\u0000\u0000\u0000\u00c7\u07d8\u0001\u0000"+ + "\u0000\u0000\u00c9\u07e2\u0001\u0000\u0000\u0000\u00cb\u07e8\u0001\u0000"+ + "\u0000\u0000\u00cd\u07ed\u0001\u0000\u0000\u0000\u00cf\u07f0\u0001\u0000"+ + "\u0000\u0000\u00d1\u07f9\u0001\u0000\u0000\u0000\u00d3\u07fe\u0001\u0000"+ + "\u0000\u0000\u00d5\u0804\u0001\u0000\u0000\u0000\u00d7\u080b\u0001\u0000"+ + "\u0000\u0000\u00d9\u0810\u0001\u0000\u0000\u0000\u00db\u0816\u0001\u0000"+ + "\u0000\u0000\u00dd\u081f\u0001\u0000\u0000\u0000\u00df\u0824\u0001\u0000"+ + "\u0000\u0000\u00e1\u082a\u0001\u0000\u0000\u0000\u00e3\u0831\u0001\u0000"+ + "\u0000\u0000\u00e5\u0836\u0001\u0000\u0000\u0000\u00e7\u0844\u0001\u0000"+ + "\u0000\u0000\u00e9\u084b\u0001\u0000\u0000\u0000\u00eb\u0855\u0001\u0000"+ + "\u0000\u0000\u00ed\u0862\u0001\u0000\u0000\u0000\u00ef\u0868\u0001\u0000"+ + "\u0000\u0000\u00f1\u0877\u0001\u0000\u0000\u0000\u00f3\u087e\u0001\u0000"+ + "\u0000\u0000\u00f5\u0883\u0001\u0000\u0000\u0000\u00f7\u0889\u0001\u0000"+ + "\u0000\u0000\u00f9\u088f\u0001\u0000\u0000\u0000\u00fb\u0892\u0001\u0000"+ + "\u0000\u0000\u00fd\u0899\u0001\u0000\u0000\u0000\u00ff\u089e\u0001\u0000"+ + "\u0000\u0000\u0101\u08a3\u0001\u0000\u0000\u0000\u0103\u08a8\u0001\u0000"+ + "\u0000\u0000\u0105\u08b0\u0001\u0000\u0000\u0000\u0107\u08b8\u0001\u0000"+ + "\u0000\u0000\u0109\u08be\u0001\u0000\u0000\u0000\u010b\u08c3\u0001\u0000"+ + "\u0000\u0000\u010d\u08cc\u0001\u0000\u0000\u0000\u010f\u08d2\u0001\u0000"+ + "\u0000\u0000\u0111\u08da\u0001\u0000\u0000\u0000\u0113\u08e2\u0001\u0000"+ + "\u0000\u0000\u0115\u08e8\u0001\u0000\u0000\u0000\u0117\u08f1\u0001\u0000"+ + "\u0000\u0000\u0119\u08f8\u0001\u0000\u0000\u0000\u011b\u08ff\u0001\u0000"+ + "\u0000\u0000\u011d\u0903\u0001\u0000\u0000\u0000\u011f\u0909\u0001\u0000"+ + "\u0000\u0000\u0121\u090f\u0001\u0000\u0000\u0000\u0123\u0919\u0001\u0000"+ + "\u0000\u0000\u0125\u091e\u0001\u0000\u0000\u0000\u0127\u0924\u0001\u0000"+ + "\u0000\u0000\u0129\u092b\u0001\u0000\u0000\u0000\u012b\u0935\u0001\u0000"+ + "\u0000\u0000\u012d\u0940\u0001\u0000\u0000\u0000\u012f\u0943\u0001\u0000"+ + "\u0000\u0000\u0131\u094d\u0001\u0000\u0000\u0000\u0133\u0956\u0001\u0000"+ + "\u0000\u0000\u0135\u095d\u0001\u0000\u0000\u0000\u0137\u0963\u0001\u0000"+ + "\u0000\u0000\u0139\u0966\u0001\u0000\u0000\u0000\u013b\u096c\u0001\u0000"+ + "\u0000\u0000\u013d\u0973\u0001\u0000\u0000\u0000\u013f\u097b\u0001\u0000"+ + "\u0000\u0000\u0141\u0984\u0001\u0000\u0000\u0000\u0143\u098c\u0001\u0000"+ + "\u0000\u0000\u0145\u0992\u0001\u0000\u0000\u0000\u0147\u09a2\u0001\u0000"+ + "\u0000\u0000\u0149\u09ad\u0001\u0000\u0000\u0000\u014b\u09b3\u0001\u0000"+ + "\u0000\u0000\u014d\u09b9\u0001\u0000\u0000\u0000\u014f\u09c1\u0001\u0000"+ + "\u0000\u0000\u0151\u09c9\u0001\u0000\u0000\u0000\u0153\u09d2\u0001\u0000"+ + "\u0000\u0000\u0155\u09d9\u0001\u0000\u0000\u0000\u0157\u09e3\u0001\u0000"+ + "\u0000\u0000\u0159\u09f1\u0001\u0000\u0000\u0000\u015b\u09fc\u0001\u0000"+ + "\u0000\u0000\u015d\u0a08\u0001\u0000\u0000\u0000\u015f\u0a10\u0001\u0000"+ + "\u0000\u0000\u0161\u0a19\u0001\u0000\u0000\u0000\u0163\u0a24\u0001\u0000"+ + "\u0000\u0000\u0165\u0a29\u0001\u0000\u0000\u0000\u0167\u0a2e\u0001\u0000"+ + "\u0000\u0000\u0169\u0a32\u0001\u0000\u0000\u0000\u016b\u0a39\u0001\u0000"+ + "\u0000\u0000\u016d\u0a3f\u0001\u0000\u0000\u0000\u016f\u0a44\u0001\u0000"+ + "\u0000\u0000\u0171\u0a4d\u0001\u0000\u0000\u0000\u0173\u0a51\u0001\u0000"+ + "\u0000\u0000\u0175\u0a5c\u0001\u0000\u0000\u0000\u0177\u0a64\u0001\u0000"+ + "\u0000\u0000\u0179\u0a6d\u0001\u0000\u0000\u0000\u017b\u0a76\u0001\u0000"+ + "\u0000\u0000\u017d\u0a7e\u0001\u0000\u0000\u0000\u017f\u0a85\u0001\u0000"+ + "\u0000\u0000\u0181\u0a8f\u0001\u0000\u0000\u0000\u0183\u0a9a\u0001\u0000"+ + "\u0000\u0000\u0185\u0aa5\u0001\u0000\u0000\u0000\u0187\u0aad\u0001\u0000"+ + "\u0000\u0000\u0189\u0ab5\u0001\u0000\u0000\u0000\u018b\u0abe\u0001\u0000"+ + "\u0000\u0000\u018d\u0ac5\u0001\u0000\u0000\u0000\u018f\u0acc\u0001\u0000"+ + "\u0000\u0000\u0191\u0ad1\u0001\u0000\u0000\u0000\u0193\u0ad6\u0001\u0000"+ + "\u0000\u0000\u0195\u0add\u0001\u0000\u0000\u0000\u0197\u0ae6\u0001\u0000"+ + "\u0000\u0000\u0199\u0af0\u0001\u0000\u0000\u0000\u019b\u0af5\u0001\u0000"+ + "\u0000\u0000\u019d\u0afc\u0001\u0000\u0000\u0000\u019f\u0b02\u0001\u0000"+ + "\u0000\u0000\u01a1\u0b0a\u0001\u0000\u0000\u0000\u01a3\u0b14\u0001\u0000"+ + "\u0000\u0000\u01a5\u0b1e\u0001\u0000\u0000\u0000\u01a7\u0b26\u0001\u0000"+ + "\u0000\u0000\u01a9\u0b2e\u0001\u0000\u0000\u0000\u01ab\u0b38\u0001\u0000"+ + "\u0000\u0000\u01ad\u0b41\u0001\u0000\u0000\u0000\u01af\u0b48\u0001\u0000"+ + "\u0000\u0000\u01b1\u0b4e\u0001\u0000\u0000\u0000\u01b3\u0b58\u0001\u0000"+ + "\u0000\u0000\u01b5\u0b5e\u0001\u0000\u0000\u0000\u01b7\u0b66\u0001\u0000"+ + "\u0000\u0000\u01b9\u0b6f\u0001\u0000\u0000\u0000\u01bb\u0b79\u0001\u0000"+ + "\u0000\u0000\u01bd\u0b80\u0001\u0000\u0000\u0000\u01bf\u0b88\u0001\u0000"+ + "\u0000\u0000\u01c1\u0b90\u0001\u0000\u0000\u0000\u01c3\u0b97\u0001\u0000"+ + "\u0000\u0000\u01c5\u0b9c\u0001\u0000\u0000\u0000\u01c7\u0ba1\u0001\u0000"+ + "\u0000\u0000\u01c9\u0baa\u0001\u0000\u0000\u0000\u01cb\u0bad\u0001\u0000"+ + "\u0000\u0000\u01cd\u0bb7\u0001\u0000\u0000\u0000\u01cf\u0bc1\u0001\u0000"+ + "\u0000\u0000\u01d1\u0bca\u0001\u0000\u0000\u0000\u01d3\u0bd4\u0001\u0000"+ + "\u0000\u0000\u01d5\u0bde\u0001\u0000\u0000\u0000\u01d7\u0be4\u0001\u0000"+ + "\u0000\u0000\u01d9\u0bec\u0001\u0000\u0000\u0000\u01db\u0bf4\u0001\u0000"+ + "\u0000\u0000\u01dd\u0bfd\u0001\u0000\u0000\u0000\u01df\u0c04\u0001\u0000"+ + "\u0000\u0000\u01e1\u0c10\u0001\u0000\u0000\u0000\u01e3\u0c17\u0001\u0000"+ + "\u0000\u0000\u01e5\u0c1f\u0001\u0000\u0000\u0000\u01e7\u0c27\u0001\u0000"+ + "\u0000\u0000\u01e9\u0c31\u0001\u0000\u0000\u0000\u01eb\u0c35\u0001\u0000"+ + "\u0000\u0000\u01ed\u0c3b\u0001\u0000\u0000\u0000\u01ef\u0c44\u0001\u0000"+ + "\u0000\u0000\u01f1\u0c4a\u0001\u0000\u0000\u0000\u01f3\u0c4f\u0001\u0000"+ + "\u0000\u0000\u01f5\u0c59\u0001\u0000\u0000\u0000\u01f7\u0c5f\u0001\u0000"+ + "\u0000\u0000\u01f9\u0c66\u0001\u0000\u0000\u0000\u01fb\u0c6b\u0001\u0000"+ + "\u0000\u0000\u01fd\u0c71\u0001\u0000\u0000\u0000\u01ff\u0c7a\u0001\u0000"+ + "\u0000\u0000\u0201\u0c7f\u0001\u0000\u0000\u0000\u0203\u0c87\u0001\u0000"+ + "\u0000\u0000\u0205\u0c8d\u0001\u0000\u0000\u0000\u0207\u0c95\u0001\u0000"+ + "\u0000\u0000\u0209\u0ca2\u0001\u0000\u0000\u0000\u020b\u0cab\u0001\u0000"+ + "\u0000\u0000\u020d\u0cb1\u0001\u0000\u0000\u0000\u020f\u0cb8\u0001\u0000"+ + "\u0000\u0000\u0211\u0cc1\u0001\u0000\u0000\u0000\u0213\u0cc6\u0001\u0000"+ + "\u0000\u0000\u0215\u0ccc\u0001\u0000\u0000\u0000\u0217\u0cd1\u0001\u0000"+ + "\u0000\u0000\u0219\u0cd6\u0001\u0000\u0000\u0000\u021b\u0cdc\u0001\u0000"+ + "\u0000\u0000\u021d\u0ce1\u0001\u0000\u0000\u0000\u021f\u0ce4\u0001\u0000"+ + "\u0000\u0000\u0221\u0cec\u0001\u0000\u0000\u0000\u0223\u0cf3\u0001\u0000"+ + "\u0000\u0000\u0225\u0cfa\u0001\u0000\u0000\u0000\u0227\u0d00\u0001\u0000"+ + "\u0000\u0000\u0229\u0d07\u0001\u0000\u0000\u0000\u022b\u0d0a\u0001\u0000"+ + "\u0000\u0000\u022d\u0d0e\u0001\u0000\u0000\u0000\u022f\u0d13\u0001\u0000"+ + "\u0000\u0000\u0231\u0d1c\u0001\u0000\u0000\u0000\u0233\u0d23\u0001\u0000"+ + "\u0000\u0000\u0235\u0d2b\u0001\u0000\u0000\u0000\u0237\u0d31\u0001\u0000"+ + "\u0000\u0000\u0239\u0d37\u0001\u0000\u0000\u0000\u023b\u0d3e\u0001\u0000"+ + "\u0000\u0000\u023d\u0d46\u0001\u0000\u0000\u0000\u023f\u0d50\u0001\u0000"+ + "\u0000\u0000\u0241\u0d58\u0001\u0000\u0000\u0000\u0243\u0d61\u0001\u0000"+ + "\u0000\u0000\u0245\u0d67\u0001\u0000\u0000\u0000\u0247\u0d71\u0001\u0000"+ + "\u0000\u0000\u0249\u0d79\u0001\u0000\u0000\u0000\u024b\u0d82\u0001\u0000"+ + "\u0000\u0000\u024d\u0d8b\u0001\u0000\u0000\u0000\u024f\u0d91\u0001\u0000"+ + "\u0000\u0000\u0251\u0d9c\u0001\u0000\u0000\u0000\u0253\u0da7\u0001\u0000"+ + "\u0000\u0000\u0255\u0db1\u0001\u0000\u0000\u0000\u0257\u0db9\u0001\u0000"+ + "\u0000\u0000\u0259\u0dbf\u0001\u0000\u0000\u0000\u025b\u0dc5\u0001\u0000"+ + "\u0000\u0000\u025d\u0dca\u0001\u0000\u0000\u0000\u025f\u0dd3\u0001\u0000"+ + "\u0000\u0000\u0261\u0ddb\u0001\u0000\u0000\u0000\u0263\u0de5\u0001\u0000"+ + "\u0000\u0000\u0265\u0de9\u0001\u0000\u0000\u0000\u0267\u0df1\u0001\u0000"+ + "\u0000\u0000\u0269\u0df9\u0001\u0000\u0000\u0000\u026b\u0e02\u0001\u0000"+ + "\u0000\u0000\u026d\u0e0a\u0001\u0000\u0000\u0000\u026f\u0e11\u0001\u0000"+ + "\u0000\u0000\u0271\u0e1c\u0001\u0000\u0000\u0000\u0273\u0e24\u0001\u0000"+ + "\u0000\u0000\u0275\u0e2c\u0001\u0000\u0000\u0000\u0277\u0e32\u0001\u0000"+ + "\u0000\u0000\u0279\u0e3a\u0001\u0000\u0000\u0000\u027b\u0e43\u0001\u0000"+ + "\u0000\u0000\u027d\u0e4b\u0001\u0000\u0000\u0000\u027f\u0e52\u0001\u0000"+ + "\u0000\u0000\u0281\u0e57\u0001\u0000\u0000\u0000\u0283\u0e60\u0001\u0000"+ + "\u0000\u0000\u0285\u0e65\u0001\u0000\u0000\u0000\u0287\u0e6a\u0001\u0000"+ + "\u0000\u0000\u0289\u0e74\u0001\u0000\u0000\u0000\u028b\u0e7b\u0001\u0000"+ + "\u0000\u0000\u028d\u0e82\u0001\u0000\u0000\u0000\u028f\u0e89\u0001\u0000"+ + "\u0000\u0000\u0291\u0e90\u0001\u0000\u0000\u0000\u0293\u0e99\u0001\u0000"+ + "\u0000\u0000\u0295\u0ea2\u0001\u0000\u0000\u0000\u0297\u0eac\u0001\u0000"+ + "\u0000\u0000\u0299\u0eb9\u0001\u0000\u0000\u0000\u029b\u0ec0\u0001\u0000"+ + "\u0000\u0000\u029d\u0ec8\u0001\u0000\u0000\u0000\u029f\u0ecc\u0001\u0000"+ + "\u0000\u0000\u02a1\u0ed2\u0001\u0000\u0000\u0000\u02a3\u0ed7\u0001\u0000"+ + "\u0000\u0000\u02a5\u0ede\u0001\u0000\u0000\u0000\u02a7\u0ee7\u0001\u0000"+ + "\u0000\u0000\u02a9\u0eee\u0001\u0000\u0000\u0000\u02ab\u0ef9\u0001\u0000"+ + "\u0000\u0000\u02ad\u0eff\u0001\u0000\u0000\u0000\u02af\u0f09\u0001\u0000"+ + "\u0000\u0000\u02b1\u0f14\u0001\u0000\u0000\u0000\u02b3\u0f1a\u0001\u0000"+ + "\u0000\u0000\u02b5\u0f21\u0001\u0000\u0000\u0000\u02b7\u0f29\u0001\u0000"+ + "\u0000\u0000\u02b9\u0f30\u0001\u0000\u0000\u0000\u02bb\u0f36\u0001\u0000"+ + "\u0000\u0000\u02bd\u0f3c\u0001\u0000\u0000\u0000\u02bf\u0f43\u0001\u0000"+ + "\u0000\u0000\u02c1\u0f4a\u0001\u0000\u0000\u0000\u02c3\u0f55\u0001\u0000"+ + "\u0000\u0000\u02c5\u0f5a\u0001\u0000\u0000\u0000\u02c7\u0f63\u0001\u0000"+ + "\u0000\u0000\u02c9\u0f6d\u0001\u0000\u0000\u0000\u02cb\u0f72\u0001\u0000"+ + "\u0000\u0000\u02cd\u0f7e\u0001\u0000\u0000\u0000\u02cf\u0f86\u0001\u0000"+ + "\u0000\u0000\u02d1\u0f8f\u0001\u0000\u0000\u0000\u02d3\u0f97\u0001\u0000"+ + "\u0000\u0000\u02d5\u0f9c\u0001\u0000\u0000\u0000\u02d7\u0fa2\u0001\u0000"+ + "\u0000\u0000\u02d9\u0fac\u0001\u0000\u0000\u0000\u02db\u0fb8\u0001\u0000"+ + "\u0000\u0000\u02dd\u0fc4\u0001\u0000\u0000\u0000\u02df\u0fcc\u0001\u0000"+ + "\u0000\u0000\u02e1\u0fd5\u0001\u0000\u0000\u0000\u02e3\u0fde\u0001\u0000"+ + "\u0000\u0000\u02e5\u0fe4\u0001\u0000\u0000\u0000\u02e7\u0feb\u0001\u0000"+ + "\u0000\u0000\u02e9\u0ff2\u0001\u0000\u0000\u0000\u02eb\u0ff8\u0001\u0000"+ + "\u0000\u0000\u02ed\u1001\u0001\u0000\u0000\u0000\u02ef\u100b\u0001\u0000"+ + "\u0000\u0000\u02f1\u1013\u0001\u0000\u0000\u0000"; private static final String _serializedATNSegment1 = - "\u0001\u0000\u0000\u0000\u0000\u035f\u0001\u0000\u0000\u0000\u0000\u0361"+ - "\u0001\u0000\u0000\u0000\u0000\u0363\u0001\u0000\u0000\u0000\u0000\u0365"+ - "\u0001\u0000\u0000\u0000\u0000\u0367\u0001\u0000\u0000\u0000\u0000\u0369"+ - "\u0001\u0000\u0000\u0000\u0000\u036b\u0001\u0000\u0000\u0000\u0000\u036d"+ - "\u0001\u0000\u0000\u0000\u0000\u036f\u0001\u0000\u0000\u0000\u0000\u0371"+ - "\u0001\u0000\u0000\u0000\u0000\u0373\u0001\u0000\u0000\u0000\u0000\u0375"+ - "\u0001\u0000\u0000\u0000\u0000\u0377\u0001\u0000\u0000\u0000\u0000\u0379"+ - "\u0001\u0000\u0000\u0000\u0000\u037b\u0001\u0000\u0000\u0000\u0000\u037d"+ - "\u0001\u0000\u0000\u0000\u0000\u037f\u0001\u0000\u0000\u0000\u0000\u0381"+ - "\u0001\u0000\u0000\u0000\u0000\u0383\u0001\u0000\u0000\u0000\u0000\u0385"+ - "\u0001\u0000\u0000\u0000\u0000\u0387\u0001\u0000\u0000\u0000\u0000\u0389"+ - "\u0001\u0000\u0000\u0000\u0000\u038b\u0001\u0000\u0000\u0000\u0000\u038d"+ - "\u0001\u0000\u0000\u0000\u0000\u038f\u0001\u0000\u0000\u0000\u0000\u0391"+ - "\u0001\u0000\u0000\u0000\u0000\u0393\u0001\u0000\u0000\u0000\u0000\u0395"+ - "\u0001\u0000\u0000\u0000\u0000\u0397\u0001\u0000\u0000\u0000\u0000\u0399"+ - "\u0001\u0000\u0000\u0000\u0000\u039b\u0001\u0000\u0000\u0000\u0000\u039d"+ - "\u0001\u0000\u0000\u0000\u0000\u039f\u0001\u0000\u0000\u0000\u0000\u03a1"+ - "\u0001\u0000\u0000\u0000\u0000\u03a3\u0001\u0000\u0000\u0000\u0000\u03a5"+ - "\u0001\u0000\u0000\u0000\u0000\u03a7\u0001\u0000\u0000\u0000\u0000\u03a9"+ - "\u0001\u0000\u0000\u0000\u0000\u03ab\u0001\u0000\u0000\u0000\u0000\u03ad"+ - "\u0001\u0000\u0000\u0000\u0000\u03af\u0001\u0000\u0000\u0000\u0000\u03b1"+ - "\u0001\u0000\u0000\u0000\u0000\u03b3\u0001\u0000\u0000\u0000\u0000\u03b5"+ - "\u0001\u0000\u0000\u0000\u0000\u03b7\u0001\u0000\u0000\u0000\u0000\u03b9"+ - "\u0001\u0000\u0000\u0000\u0000\u03bb\u0001\u0000\u0000\u0000\u0000\u03bd"+ - "\u0001\u0000\u0000\u0000\u0000\u03bf\u0001\u0000\u0000\u0000\u0000\u03c1"+ - "\u0001\u0000\u0000\u0000\u0000\u03c3\u0001\u0000\u0000\u0000\u0000\u03c5"+ - "\u0001\u0000\u0000\u0000\u0000\u03c7\u0001\u0000\u0000\u0000\u0000\u03c9"+ - "\u0001\u0000\u0000\u0000\u0000\u03cb\u0001\u0000\u0000\u0000\u0000\u03cd"+ - "\u0001\u0000\u0000\u0000\u0000\u03cf\u0001\u0000\u0000\u0000\u0000\u03d1"+ - "\u0001\u0000\u0000\u0000\u0000\u03d3\u0001\u0000\u0000\u0000\u0000\u03d5"+ - "\u0001\u0000\u0000\u0000\u0000\u03d7\u0001\u0000\u0000\u0000\u0000\u03d9"+ - "\u0001\u0000\u0000\u0000\u0000\u03db\u0001\u0000\u0000\u0000\u0000\u03dd"+ - "\u0001\u0000\u0000\u0000\u0000\u03df\u0001\u0000\u0000\u0000\u0000\u03e1"+ - "\u0001\u0000\u0000\u0000\u0000\u03e3\u0001\u0000\u0000\u0000\u0000\u03e5"+ - "\u0001\u0000\u0000\u0000\u0000\u03e7\u0001\u0000\u0000\u0000\u0000\u03e9"+ - "\u0001\u0000\u0000\u0000\u0000\u03eb\u0001\u0000\u0000\u0000\u0000\u03ed"+ - "\u0001\u0000\u0000\u0000\u0000\u03ef\u0001\u0000\u0000\u0000\u0000\u03f1"+ - "\u0001\u0000\u0000\u0000\u0000\u03f3\u0001\u0000\u0000\u0000\u0000\u03f5"+ - "\u0001\u0000\u0000\u0000\u0000\u03f7\u0001\u0000\u0000\u0000\u0000\u03f9"+ - "\u0001\u0000\u0000\u0000\u0000\u03fb\u0001\u0000\u0000\u0000\u0000\u03fd"+ - "\u0001\u0000\u0000\u0000\u0000\u03ff\u0001\u0000\u0000\u0000\u0000\u0401"+ - "\u0001\u0000\u0000\u0000\u0000\u0403\u0001\u0000\u0000\u0000\u0000\u0405"+ - "\u0001\u0000\u0000\u0000\u0000\u0407\u0001\u0000\u0000\u0000\u0000\u0409"+ - "\u0001\u0000\u0000\u0000\u0000\u040b\u0001\u0000\u0000\u0000\u0000\u040d"+ - "\u0001\u0000\u0000\u0000\u0000\u040f\u0001\u0000\u0000\u0000\u0000\u0411"+ - "\u0001\u0000\u0000\u0000\u0000\u0413\u0001\u0000\u0000\u0000\u0000\u0415"+ - "\u0001\u0000\u0000\u0000\u0000\u0417\u0001\u0000\u0000\u0000\u0000\u0419"+ - "\u0001\u0000\u0000\u0000\u0000\u041b\u0001\u0000\u0000\u0000\u0000\u041d"+ - "\u0001\u0000\u0000\u0000\u0000\u041f\u0001\u0000\u0000\u0000\u0000\u0421"+ - "\u0001\u0000\u0000\u0000\u0000\u0423\u0001\u0000\u0000\u0000\u0000\u0425"+ - "\u0001\u0000\u0000\u0000\u0000\u0427\u0001\u0000\u0000\u0000\u0000\u0429"+ - "\u0001\u0000\u0000\u0000\u0000\u042b\u0001\u0000\u0000\u0000\u0000\u042d"+ - "\u0001\u0000\u0000\u0000\u0000\u042f\u0001\u0000\u0000\u0000\u0000\u0431"+ - "\u0001\u0000\u0000\u0000\u0000\u0433\u0001\u0000\u0000\u0000\u0000\u0435"+ - "\u0001\u0000\u0000\u0000\u0000\u0437\u0001\u0000\u0000\u0000\u0000\u0439"+ - "\u0001\u0000\u0000\u0000\u0000\u043b\u0001\u0000\u0000\u0000\u0000\u043d"+ - "\u0001\u0000\u0000\u0000\u0000\u043f\u0001\u0000\u0000\u0000\u0000\u0441"+ - "\u0001\u0000\u0000\u0000\u0000\u0443\u0001\u0000\u0000\u0000\u0000\u0445"+ - "\u0001\u0000\u0000\u0000\u0000\u0447\u0001\u0000\u0000\u0000\u0000\u0449"+ - "\u0001\u0000\u0000\u0000\u0000\u044b\u0001\u0000\u0000\u0000\u0000\u044d"+ - "\u0001\u0000\u0000\u0000\u0000\u044f\u0001\u0000\u0000\u0000\u0000\u0451"+ - "\u0001\u0000\u0000\u0000\u0000\u0453\u0001\u0000\u0000\u0000\u0000\u0455"+ - "\u0001\u0000\u0000\u0000\u0000\u0457\u0001\u0000\u0000\u0000\u0000\u0459"+ - "\u0001\u0000\u0000\u0000\u0000\u045b\u0001\u0000\u0000\u0000\u0000\u045d"+ - "\u0001\u0000\u0000\u0000\u0000\u045f\u0001\u0000\u0000\u0000\u0000\u0461"+ - "\u0001\u0000\u0000\u0000\u0000\u0463\u0001\u0000\u0000\u0000\u0000\u0465"+ - "\u0001\u0000\u0000\u0000\u0000\u0467\u0001\u0000\u0000\u0000\u0000\u0469"+ - "\u0001\u0000\u0000\u0000\u0000\u046b\u0001\u0000\u0000\u0000\u0000\u046d"+ - "\u0001\u0000\u0000\u0000\u0000\u046f\u0001\u0000\u0000\u0000\u0000\u0471"+ - "\u0001\u0000\u0000\u0000\u0000\u0473\u0001\u0000\u0000\u0000\u0000\u0475"+ - "\u0001\u0000\u0000\u0000\u0000\u0477\u0001\u0000\u0000\u0000\u0000\u0479"+ - "\u0001\u0000\u0000\u0000\u0000\u047b\u0001\u0000\u0000\u0000\u0000\u047d"+ - "\u0001\u0000\u0000\u0000\u0000\u047f\u0001\u0000\u0000\u0000\u0000\u0481"+ - "\u0001\u0000\u0000\u0000\u0000\u0483\u0001\u0000\u0000\u0000\u0000\u0485"+ - "\u0001\u0000\u0000\u0000\u0000\u0487\u0001\u0000\u0000\u0000\u0000\u0489"+ - "\u0001\u0000\u0000\u0000\u0000\u048b\u0001\u0000\u0000\u0000\u0000\u048d"+ - "\u0001\u0000\u0000\u0000\u0000\u048f\u0001\u0000\u0000\u0000\u0000\u0491"+ - "\u0001\u0000\u0000\u0000\u0000\u0493\u0001\u0000\u0000\u0000\u0000\u0495"+ - "\u0001\u0000\u0000\u0000\u0000\u0497\u0001\u0000\u0000\u0000\u0000\u0499"+ - "\u0001\u0000\u0000\u0000\u0000\u049b\u0001\u0000\u0000\u0000\u0000\u049d"+ - "\u0001\u0000\u0000\u0000\u0000\u049f\u0001\u0000\u0000\u0000\u0000\u04a1"+ - "\u0001\u0000\u0000\u0000\u0000\u04a3\u0001\u0000\u0000\u0000\u0000\u04a5"+ - "\u0001\u0000\u0000\u0000\u0000\u04a7\u0001\u0000\u0000\u0000\u0000\u04a9"+ - "\u0001\u0000\u0000\u0000\u0000\u04ab\u0001\u0000\u0000\u0000\u0000\u04ad"+ - "\u0001\u0000\u0000\u0000\u0000\u04af\u0001\u0000\u0000\u0000\u0000\u04b1"+ - "\u0001\u0000\u0000\u0000\u0000\u04b3\u0001\u0000\u0000\u0000\u0000\u04b5"+ - "\u0001\u0000\u0000\u0000\u0000\u04b7\u0001\u0000\u0000\u0000\u0000\u04b9"+ - "\u0001\u0000\u0000\u0000\u0000\u04bb\u0001\u0000\u0000\u0000\u0000\u04bd"+ - "\u0001\u0000\u0000\u0000\u0000\u04bf\u0001\u0000\u0000\u0000\u0000\u04c1"+ - "\u0001\u0000\u0000\u0000\u0000\u04c3\u0001\u0000\u0000\u0000\u0000\u04c5"+ - "\u0001\u0000\u0000\u0000\u0000\u04c7\u0001\u0000\u0000\u0000\u0000\u04c9"+ - "\u0001\u0000\u0000\u0000\u0000\u04cb\u0001\u0000\u0000\u0000\u0000\u04cd"+ - "\u0001\u0000\u0000\u0000\u0000\u04cf\u0001\u0000\u0000\u0000\u0000\u04d1"+ - "\u0001\u0000\u0000\u0000\u0000\u04d3\u0001\u0000\u0000\u0000\u0000\u04d5"+ - "\u0001\u0000\u0000\u0000\u0000\u04d7\u0001\u0000\u0000\u0000\u0000\u04d9"+ - "\u0001\u0000\u0000\u0000\u0000\u04db\u0001\u0000\u0000\u0000\u0000\u04dd"+ - "\u0001\u0000\u0000\u0000\u0000\u04df\u0001\u0000\u0000\u0000\u0000\u04e1"+ - "\u0001\u0000\u0000\u0000\u0000\u04e3\u0001\u0000\u0000\u0000\u0000\u04e5"+ - "\u0001\u0000\u0000\u0000\u0000\u04e7\u0001\u0000\u0000\u0000\u0000\u04e9"+ - "\u0001\u0000\u0000\u0000\u0000\u04eb\u0001\u0000\u0000\u0000\u0000\u04ed"+ - "\u0001\u0000\u0000\u0000\u0000\u04ef\u0001\u0000\u0000\u0000\u0000\u04f1"+ - "\u0001\u0000\u0000\u0000\u0000\u04f3\u0001\u0000\u0000\u0000\u0000\u04f5"+ - "\u0001\u0000\u0000\u0000\u0000\u04f7\u0001\u0000\u0000\u0000\u0000\u04f9"+ - "\u0001\u0000\u0000\u0000\u0000\u04fb\u0001\u0000\u0000\u0000\u0000\u04fd"+ - "\u0001\u0000\u0000\u0000\u0000\u04ff\u0001\u0000\u0000\u0000\u0000\u0501"+ - "\u0001\u0000\u0000\u0000\u0000\u0503\u0001\u0000\u0000\u0000\u0000\u0505"+ - "\u0001\u0000\u0000\u0000\u0000\u0507\u0001\u0000\u0000\u0000\u0000\u0509"+ - "\u0001\u0000\u0000\u0000\u0000\u050b\u0001\u0000\u0000\u0000\u0000\u050d"+ - "\u0001\u0000\u0000\u0000\u0000\u050f\u0001\u0000\u0000\u0000\u0000\u0511"+ - "\u0001\u0000\u0000\u0000\u0000\u0513\u0001\u0000\u0000\u0000\u0000\u0515"+ - "\u0001\u0000\u0000\u0000\u0000\u0517\u0001\u0000\u0000\u0000\u0000\u0519"+ - "\u0001\u0000\u0000\u0000\u0000\u051b\u0001\u0000\u0000\u0000\u0000\u051d"+ - "\u0001\u0000\u0000\u0000\u0000\u051f\u0001\u0000\u0000\u0000\u0000\u0521"+ - "\u0001\u0000\u0000\u0000\u0000\u0523\u0001\u0000\u0000\u0000\u0000\u0525"+ - "\u0001\u0000\u0000\u0000\u0000\u0527\u0001\u0000\u0000\u0000\u0000\u0529"+ - "\u0001\u0000\u0000\u0000\u0000\u052b\u0001\u0000\u0000\u0000\u0000\u052d"+ - "\u0001\u0000\u0000\u0000\u0000\u052f\u0001\u0000\u0000\u0000\u0000\u0531"+ - "\u0001\u0000\u0000\u0000\u0000\u0533\u0001\u0000\u0000\u0000\u0000\u0535"+ - "\u0001\u0000\u0000\u0000\u0000\u0537\u0001\u0000\u0000\u0000\u0000\u0539"+ - "\u0001\u0000\u0000\u0000\u0000\u053b\u0001\u0000\u0000\u0000\u0000\u053d"+ - "\u0001\u0000\u0000\u0000\u0000\u053f\u0001\u0000\u0000\u0000\u0000\u0541"+ - "\u0001\u0000\u0000\u0000\u0000\u0543\u0001\u0000\u0000\u0000\u0000\u0545"+ - "\u0001\u0000\u0000\u0000\u0000\u0547\u0001\u0000\u0000\u0000\u0000\u0549"+ - "\u0001\u0000\u0000\u0000\u0000\u054b\u0001\u0000\u0000\u0000\u0000\u054d"+ - "\u0001\u0000\u0000\u0000\u0000\u054f\u0001\u0000\u0000\u0000\u0000\u0551"+ - "\u0001\u0000\u0000\u0000\u0000\u0553\u0001\u0000\u0000\u0000\u0000\u0555"+ - "\u0001\u0000\u0000\u0000\u0000\u0557\u0001\u0000\u0000\u0000\u0000\u0559"+ - "\u0001\u0000\u0000\u0000\u0000\u055b\u0001\u0000\u0000\u0000\u0000\u055d"+ - "\u0001\u0000\u0000\u0000\u0000\u055f\u0001\u0000\u0000\u0000\u0000\u0561"+ - "\u0001\u0000\u0000\u0000\u0000\u0563\u0001\u0000\u0000\u0000\u0000\u0565"+ - "\u0001\u0000\u0000\u0000\u0000\u0567\u0001\u0000\u0000\u0000\u0000\u0569"+ - "\u0001\u0000\u0000\u0000\u0000\u056b\u0001\u0000\u0000\u0000\u0000\u056d"+ - "\u0001\u0000\u0000\u0000\u0000\u056f\u0001\u0000\u0000\u0000\u0000\u0571"+ - "\u0001\u0000\u0000\u0000\u0000\u0573\u0001\u0000\u0000\u0000\u0000\u0575"+ - "\u0001\u0000\u0000\u0000\u0000\u0577\u0001\u0000\u0000\u0000\u0000\u0579"+ - "\u0001\u0000\u0000\u0000\u0000\u057b\u0001\u0000\u0000\u0000\u0000\u057d"+ - "\u0001\u0000\u0000\u0000\u0000\u057f\u0001\u0000\u0000\u0000\u0000\u0581"+ - "\u0001\u0000\u0000\u0000\u0000\u0583\u0001\u0000\u0000\u0000\u0000\u0585"+ - "\u0001\u0000\u0000\u0000\u0000\u0587\u0001\u0000\u0000\u0000\u0000\u0589"+ - "\u0001\u0000\u0000\u0000\u0000\u058b\u0001\u0000\u0000\u0000\u0000\u058d"+ - "\u0001\u0000\u0000\u0000\u0000\u058f\u0001\u0000\u0000\u0000\u0000\u0591"+ - "\u0001\u0000\u0000\u0000\u0000\u0593\u0001\u0000\u0000\u0000\u0000\u0595"+ - "\u0001\u0000\u0000\u0000\u0000\u0597\u0001\u0000\u0000\u0000\u0000\u0599"+ - "\u0001\u0000\u0000\u0000\u0000\u059b\u0001\u0000\u0000\u0000\u0000\u059d"+ - "\u0001\u0000\u0000\u0000\u0000\u059f\u0001\u0000\u0000\u0000\u0000\u05a1"+ - "\u0001\u0000\u0000\u0000\u0000\u05a3\u0001\u0000\u0000\u0000\u0000\u05a5"+ - "\u0001\u0000\u0000\u0000\u0000\u05a7\u0001\u0000\u0000\u0000\u0000\u05a9"+ - "\u0001\u0000\u0000\u0000\u0000\u05ab\u0001\u0000\u0000\u0000\u0000\u05ad"+ - "\u0001\u0000\u0000\u0000\u0000\u05af\u0001\u0000\u0000\u0000\u0000\u05b1"+ - "\u0001\u0000\u0000\u0000\u0000\u05b3\u0001\u0000\u0000\u0000\u0000\u05b5"+ - "\u0001\u0000\u0000\u0000\u0000\u05b7\u0001\u0000\u0000\u0000\u0000\u05b9"+ - "\u0001\u0000\u0000\u0000\u0000\u05bb\u0001\u0000\u0000\u0000\u0000\u05bd"+ - "\u0001\u0000\u0000\u0000\u0000\u05bf\u0001\u0000\u0000\u0000\u0000\u05c1"+ - "\u0001\u0000\u0000\u0000\u0000\u05c3\u0001\u0000\u0000\u0000\u0000\u05c5"+ - "\u0001\u0000\u0000\u0000\u0000\u05c7\u0001\u0000\u0000\u0000\u0000\u05c9"+ - "\u0001\u0000\u0000\u0000\u0000\u05cb\u0001\u0000\u0000\u0000\u0000\u05cd"+ - "\u0001\u0000\u0000\u0000\u0000\u05cf\u0001\u0000\u0000\u0000\u0000\u05d1"+ - "\u0001\u0000\u0000\u0000\u0000\u05d3\u0001\u0000\u0000\u0000\u0000\u05d5"+ - "\u0001\u0000\u0000\u0000\u0000\u05d7\u0001\u0000\u0000\u0000\u0000\u05d9"+ - "\u0001\u0000\u0000\u0000\u0000\u05db\u0001\u0000\u0000\u0000\u0000\u05dd"+ - "\u0001\u0000\u0000\u0000\u0000\u05df\u0001\u0000\u0000\u0000\u0000\u05e1"+ - "\u0001\u0000\u0000\u0000\u0000\u05e3\u0001\u0000\u0000\u0000\u0000\u05e5"+ - "\u0001\u0000\u0000\u0000\u0000\u05e7\u0001\u0000\u0000\u0000\u0000\u05e9"+ - "\u0001\u0000\u0000\u0000\u0000\u05eb\u0001\u0000\u0000\u0000\u0000\u05ed"+ - "\u0001\u0000\u0000\u0000\u0000\u05ef\u0001\u0000\u0000\u0000\u0000\u05f1"+ - "\u0001\u0000\u0000\u0000\u0000\u05f3\u0001\u0000\u0000\u0000\u0000\u05f5"+ - "\u0001\u0000\u0000\u0000\u0000\u05f7\u0001\u0000\u0000\u0000\u0000\u05f9"+ - "\u0001\u0000\u0000\u0000\u0000\u05fb\u0001\u0000\u0000\u0000\u0000\u05fd"+ - "\u0001\u0000\u0000\u0000\u0000\u05ff\u0001\u0000\u0000\u0000\u0000\u0601"+ - "\u0001\u0000\u0000\u0000\u0000\u0603\u0001\u0000\u0000\u0000\u0000\u0605"+ - "\u0001\u0000\u0000\u0000\u0000\u0607\u0001\u0000\u0000\u0000\u0000\u0609"+ - "\u0001\u0000\u0000\u0000\u0000\u060b\u0001\u0000\u0000\u0000\u0000\u060d"+ - "\u0001\u0000\u0000\u0000\u0000\u060f\u0001\u0000\u0000\u0000\u0000\u0611"+ - "\u0001\u0000\u0000\u0000\u0000\u0613\u0001\u0000\u0000\u0000\u0000\u0615"+ - "\u0001\u0000\u0000\u0000\u0000\u0617\u0001\u0000\u0000\u0000\u0000\u0619"+ - "\u0001\u0000\u0000\u0000\u0000\u061b\u0001\u0000\u0000\u0000\u0000\u061d"+ - "\u0001\u0000\u0000\u0000\u0000\u061f\u0001\u0000\u0000\u0000\u0000\u0621"+ - "\u0001\u0000\u0000\u0000\u0000\u0623\u0001\u0000\u0000\u0000\u0000\u0625"+ - "\u0001\u0000\u0000\u0000\u0000\u0627\u0001\u0000\u0000\u0000\u0000\u0629"+ - "\u0001\u0000\u0000\u0000\u0000\u062b\u0001\u0000\u0000\u0000\u0000\u062d"+ - "\u0001\u0000\u0000\u0000\u0000\u062f\u0001\u0000\u0000\u0000\u0000\u0631"+ - "\u0001\u0000\u0000\u0000\u0000\u0633\u0001\u0000\u0000\u0000\u0000\u0635"+ - "\u0001\u0000\u0000\u0000\u0000\u0637\u0001\u0000\u0000\u0000\u0000\u0639"+ - "\u0001\u0000\u0000\u0000\u0000\u063b\u0001\u0000\u0000\u0000\u0000\u063d"+ - "\u0001\u0000\u0000\u0000\u0000\u063f\u0001\u0000\u0000\u0000\u0000\u0641"+ - "\u0001\u0000\u0000\u0000\u0000\u0643\u0001\u0000\u0000\u0000\u0000\u0645"+ - "\u0001\u0000\u0000\u0000\u0000\u0647\u0001\u0000\u0000\u0000\u0000\u0649"+ - "\u0001\u0000\u0000\u0000\u0000\u064b\u0001\u0000\u0000\u0000\u0000\u064d"+ - "\u0001\u0000\u0000\u0000\u0000\u064f\u0001\u0000\u0000\u0000\u0000\u0651"+ - "\u0001\u0000\u0000\u0000\u0000\u0653\u0001\u0000\u0000\u0000\u0000\u0655"+ - "\u0001\u0000\u0000\u0000\u0000\u0657\u0001\u0000\u0000\u0000\u0000\u0659"+ - "\u0001\u0000\u0000\u0000\u0000\u065b\u0001\u0000\u0000\u0000\u0000\u065d"+ - "\u0001\u0000\u0000\u0000\u0000\u065f\u0001\u0000\u0000\u0000\u0000\u0661"+ - "\u0001\u0000\u0000\u0000\u0000\u0663\u0001\u0000\u0000\u0000\u0000\u0665"+ - "\u0001\u0000\u0000\u0000\u0000\u0667\u0001\u0000\u0000\u0000\u0000\u0669"+ - "\u0001\u0000\u0000\u0000\u0000\u066b\u0001\u0000\u0000\u0000\u0000\u066d"+ - "\u0001\u0000\u0000\u0000\u0000\u066f\u0001\u0000\u0000\u0000\u0000\u0671"+ - "\u0001\u0000\u0000\u0000\u0000\u0673\u0001\u0000\u0000\u0000\u0000\u0675"+ - "\u0001\u0000\u0000\u0000\u0000\u0677\u0001\u0000\u0000\u0000\u0000\u0679"+ - "\u0001\u0000\u0000\u0000\u0000\u067b\u0001\u0000\u0000\u0000\u0000\u067d"+ - "\u0001\u0000\u0000\u0000\u0000\u067f\u0001\u0000\u0000\u0000\u0000\u0681"+ - "\u0001\u0000\u0000\u0000\u0000\u0683\u0001\u0000\u0000\u0000\u0000\u0685"+ - "\u0001\u0000\u0000\u0000\u0000\u0687\u0001\u0000\u0000\u0000\u0000\u0689"+ - "\u0001\u0000\u0000\u0000\u0000\u068b\u0001\u0000\u0000\u0000\u0000\u068d"+ - "\u0001\u0000\u0000\u0000\u0000\u068f\u0001\u0000\u0000\u0000\u0000\u0691"+ - "\u0001\u0000\u0000\u0000\u0000\u0693\u0001\u0000\u0000\u0000\u0000\u0695"+ - "\u0001\u0000\u0000\u0000\u0000\u0697\u0001\u0000\u0000\u0000\u0000\u0699"+ - "\u0001\u0000\u0000\u0000\u0000\u069b\u0001\u0000\u0000\u0000\u0000\u069d"+ - "\u0001\u0000\u0000\u0000\u0000\u069f\u0001\u0000\u0000\u0000\u0000\u06a1"+ - "\u0001\u0000\u0000\u0000\u0000\u06a3\u0001\u0000\u0000\u0000\u0000\u06a5"+ - "\u0001\u0000\u0000\u0000\u0000\u06a7\u0001\u0000\u0000\u0000\u0000\u06a9"+ - "\u0001\u0000\u0000\u0000\u0000\u06ab\u0001\u0000\u0000\u0000\u0000\u06ad"+ - "\u0001\u0000\u0000\u0000\u0000\u06af\u0001\u0000\u0000\u0000\u0000\u06b1"+ - "\u0001\u0000\u0000\u0000\u0000\u06b3\u0001\u0000\u0000\u0000\u0000\u06b5"+ - "\u0001\u0000\u0000\u0000\u0000\u06b7\u0001\u0000\u0000\u0000\u0000\u06b9"+ - "\u0001\u0000\u0000\u0000\u0000\u06bb\u0001\u0000\u0000\u0000\u0000\u06bd"+ - "\u0001\u0000\u0000\u0000\u0000\u06bf\u0001\u0000\u0000\u0000\u0000\u06c1"+ - "\u0001\u0000\u0000\u0000\u0000\u06c3\u0001\u0000\u0000\u0000\u0000\u06c5"+ - "\u0001\u0000\u0000\u0000\u0000\u06c7\u0001\u0000\u0000\u0000\u0001\u06cc"+ - "\u0001\u0000\u0000\u0000\u0003\u06d2\u0001\u0000\u0000\u0000\u0005\u06e0"+ - "\u0001\u0000\u0000\u0000\u0007\u06ed\u0001\u0000\u0000\u0000\t\u06ef\u0001"+ - "\u0000\u0000\u0000\u000b\u06f1\u0001\u0000\u0000\u0000\r\u06f3\u0001\u0000"+ - "\u0000\u0000\u000f\u06f5\u0001\u0000\u0000\u0000\u0011\u06f7\u0001\u0000"+ - "\u0000\u0000\u0013\u06f9\u0001\u0000\u0000\u0000\u0015\u06fb\u0001\u0000"+ - "\u0000\u0000\u0017\u06fd\u0001\u0000\u0000\u0000\u0019\u06ff\u0001\u0000"+ - "\u0000\u0000\u001b\u0701\u0001\u0000\u0000\u0000\u001d\u0703\u0001\u0000"+ - "\u0000\u0000\u001f\u0705\u0001\u0000\u0000\u0000!\u0707\u0001\u0000\u0000"+ - "\u0000#\u0709\u0001\u0000\u0000\u0000%\u070b\u0001\u0000\u0000\u0000\'"+ - "\u070d\u0001\u0000\u0000\u0000)\u070f\u0001\u0000\u0000\u0000+\u0711\u0001"+ - "\u0000\u0000\u0000-\u0713\u0001\u0000\u0000\u0000/\u0715\u0001\u0000\u0000"+ - "\u00001\u0717\u0001\u0000\u0000\u00003\u0719\u0001\u0000\u0000\u00005"+ - "\u071b\u0001\u0000\u0000\u00007\u071d\u0001\u0000\u0000\u00009\u071f\u0001"+ - "\u0000\u0000\u0000;\u0721\u0001\u0000\u0000\u0000=\u0723\u0001\u0000\u0000"+ - "\u0000?\u0725\u0001\u0000\u0000\u0000A\u0732\u0001\u0000\u0000\u0000C"+ - "\u073f\u0001\u0000\u0000\u0000E\u074c\u0001\u0000\u0000\u0000G\u074e\u0001"+ - "\u0000\u0000\u0000I\u0754\u0001\u0000\u0000\u0000K\u0758\u0001\u0000\u0000"+ - "\u0000M\u0761\u0001\u0000\u0000\u0000O\u0768\u0001\u0000\u0000\u0000Q"+ - "\u076f\u0001\u0000\u0000\u0000S\u0773\u0001\u0000\u0000\u0000U\u0777\u0001"+ - "\u0000\u0000\u0000W\u077d\u0001\u0000\u0000\u0000Y\u0783\u0001\u0000\u0000"+ - "\u0000[\u078d\u0001\u0000\u0000\u0000]\u0793\u0001\u0000\u0000\u0000_"+ - "\u0797\u0001\u0000\u0000\u0000a\u07a0\u0001\u0000\u0000\u0000c\u07a5\u0001"+ - "\u0000\u0000\u0000e\u07ab\u0001\u0000\u0000\u0000g\u07b2\u0001\u0000\u0000"+ - "\u0000i\u07ba\u0001\u0000\u0000\u0000k\u07c2\u0001\u0000\u0000\u0000m"+ - "\u07c6\u0001\u0000\u0000\u0000o\u07ca\u0001\u0000\u0000\u0000q\u07ce\u0001"+ - "\u0000\u0000\u0000s\u07d4\u0001\u0000\u0000\u0000u\u07d7\u0001\u0000\u0000"+ - "\u0000w\u07db\u0001\u0000\u0000\u0000y\u07e6\u0001\u0000\u0000\u0000{"+ - "\u07f0\u0001\u0000\u0000\u0000}\u07fb\u0001\u0000\u0000\u0000\u007f\u0806"+ - "\u0001\u0000\u0000\u0000\u0081\u0809\u0001\u0000\u0000\u0000\u0083\u0810"+ - "\u0001\u0000\u0000\u0000\u0085\u081a\u0001\u0000\u0000\u0000\u0087\u0825"+ - "\u0001\u0000\u0000\u0000\u0089\u0833\u0001\u0000\u0000\u0000\u008b\u0837"+ - "\u0001\u0000\u0000\u0000\u008d\u0840\u0001\u0000\u0000\u0000\u008f\u0847"+ - "\u0001\u0000\u0000\u0000\u0091\u084d\u0001\u0000\u0000\u0000\u0093\u0857"+ - "\u0001\u0000\u0000\u0000\u0095\u085f\u0001\u0000\u0000\u0000\u0097\u0866"+ - "\u0001\u0000\u0000\u0000\u0099\u086d\u0001\u0000\u0000\u0000\u009b\u0871"+ - "\u0001\u0000\u0000\u0000\u009d\u087c\u0001\u0000\u0000\u0000\u009f\u0883"+ - "\u0001\u0000\u0000\u0000\u00a1\u0888\u0001\u0000\u0000\u0000\u00a3\u0890"+ - "\u0001\u0000\u0000\u0000\u00a5\u0895\u0001\u0000\u0000\u0000\u00a7\u089d"+ - "\u0001\u0000\u0000\u0000\u00a9\u08a5\u0001\u0000\u0000\u0000\u00ab\u08a8"+ - "\u0001\u0000\u0000\u0000\u00ad\u08aa\u0001\u0000\u0000\u0000\u00af\u08b0"+ - "\u0001\u0000\u0000\u0000\u00b1\u08b5\u0001\u0000\u0000\u0000\u00b3\u08bc"+ - "\u0001\u0000\u0000\u0000\u00b5\u08c8\u0001\u0000\u0000\u0000\u00b7\u08d0"+ - "\u0001\u0000\u0000\u0000\u00b9\u08d9\u0001\u0000\u0000\u0000\u00bb\u08de"+ - "\u0001\u0000\u0000\u0000\u00bd\u08e3\u0001\u0000\u0000\u0000\u00bf\u08eb"+ - "\u0001\u0000\u0000\u0000\u00c1\u08f8\u0001\u0000\u0000\u0000\u00c3\u08fd"+ - "\u0001\u0000\u0000\u0000\u00c5\u0905\u0001\u0000\u0000\u0000\u00c7\u090b"+ - "\u0001\u0000\u0000\u0000\u00c9\u0910\u0001\u0000\u0000\u0000\u00cb\u091c"+ - "\u0001\u0000\u0000\u0000\u00cd\u0926\u0001\u0000\u0000\u0000\u00cf\u0937"+ - "\u0001\u0000\u0000\u0000\u00d1\u094d\u0001\u0000\u0000\u0000\u00d3\u0960"+ - "\u0001\u0000\u0000\u0000\u00d5\u0975\u0001\u0000\u0000\u0000\u00d7\u0985"+ - "\u0001\u0000\u0000\u0000\u00d9\u0990\u0001\u0000\u0000\u0000\u00db\u0996"+ - "\u0001\u0000\u0000\u0000\u00dd\u099e\u0001\u0000\u0000\u0000\u00df\u09a9"+ - "\u0001\u0000\u0000\u0000\u00e1\u09af\u0001\u0000\u0000\u0000\u00e3\u09bc"+ - "\u0001\u0000\u0000\u0000\u00e5\u09c1\u0001\u0000\u0000\u0000\u00e7\u09c7"+ - "\u0001\u0000\u0000\u0000\u00e9\u09cf\u0001\u0000\u0000\u0000\u00eb\u09d8"+ - "\u0001\u0000\u0000\u0000\u00ed\u09de\u0001\u0000\u0000\u0000\u00ef\u09e6"+ - "\u0001\u0000\u0000\u0000\u00f1\u09f0\u0001\u0000\u0000\u0000\u00f3\u0a02"+ - "\u0001\u0000\u0000\u0000\u00f5\u0a11\u0001\u0000\u0000\u0000\u00f7\u0a22"+ - "\u0001\u0000\u0000\u0000\u00f9\u0a2a\u0001\u0000\u0000\u0000\u00fb\u0a31"+ - "\u0001\u0000\u0000\u0000\u00fd\u0a3d\u0001\u0000\u0000\u0000\u00ff\u0a4e"+ - "\u0001\u0000\u0000\u0000\u0101\u0a64\u0001\u0000\u0000\u0000\u0103\u0a6c"+ - "\u0001\u0000\u0000\u0000\u0105\u0a73\u0001\u0000\u0000\u0000\u0107\u0a7d"+ - "\u0001\u0000\u0000\u0000\u0109\u0a88\u0001\u0000\u0000\u0000\u010b\u0a92"+ - "\u0001\u0000\u0000\u0000\u010d\u0aa3\u0001\u0000\u0000\u0000\u010f\u0ab1"+ - "\u0001\u0000\u0000\u0000\u0111\u0aba\u0001\u0000\u0000\u0000\u0113\u0ac2"+ - "\u0001\u0000\u0000\u0000\u0115\u0acd\u0001\u0000\u0000\u0000\u0117\u0add"+ - "\u0001\u0000\u0000\u0000\u0119\u0ae8\u0001\u0000\u0000\u0000\u011b\u0afb"+ - "\u0001\u0000\u0000\u0000\u011d\u0b0b\u0001\u0000\u0000\u0000\u011f\u0b1d"+ - "\u0001\u0000\u0000\u0000\u0121\u0b29\u0001\u0000\u0000\u0000\u0123\u0b35"+ - "\u0001\u0000\u0000\u0000\u0125\u0b3e\u0001\u0000\u0000\u0000\u0127\u0b47"+ - "\u0001\u0000\u0000\u0000\u0129\u0b52\u0001\u0000\u0000\u0000\u012b\u0b5a"+ - "\u0001\u0000\u0000\u0000\u012d\u0b5f\u0001\u0000\u0000\u0000\u012f\u0b64"+ - "\u0001\u0000\u0000\u0000\u0131\u0b72\u0001\u0000\u0000\u0000\u0133\u0b78"+ - "\u0001\u0000\u0000\u0000\u0135\u0b7e\u0001\u0000\u0000\u0000\u0137\u0b88"+ - "\u0001\u0000\u0000\u0000\u0139\u0b93\u0001\u0000\u0000\u0000\u013b\u0b9a"+ - "\u0001\u0000\u0000\u0000\u013d\u0ba3\u0001\u0000\u0000\u0000\u013f\u0bae"+ - "\u0001\u0000\u0000\u0000\u0141\u0bb4\u0001\u0000\u0000\u0000\u0143\u0bb8"+ - "\u0001\u0000\u0000\u0000\u0145\u0bbd\u0001\u0000\u0000\u0000\u0147\u0bc7"+ - "\u0001\u0000\u0000\u0000\u0149\u0bcf\u0001\u0000\u0000\u0000\u014b\u0bdc"+ - "\u0001\u0000\u0000\u0000\u014d\u0bfc\u0001\u0000\u0000\u0000\u014f\u0c09"+ - "\u0001\u0000\u0000\u0000\u0151\u0c16\u0001\u0000\u0000\u0000\u0153\u0c23"+ - "\u0001\u0000\u0000\u0000\u0155\u0c35\u0001\u0000\u0000\u0000\u0157\u0c56"+ - "\u0001\u0000\u0000\u0000\u0159\u0c63\u0001\u0000\u0000\u0000\u015b\u0c6a"+ - "\u0001\u0000\u0000\u0000\u015d\u0c76\u0001\u0000\u0000\u0000\u015f\u0c7c"+ - "\u0001\u0000\u0000\u0000\u0161\u0c81\u0001\u0000\u0000\u0000\u0163\u0c8a"+ - "\u0001\u0000\u0000\u0000\u0165\u0c8f\u0001\u0000\u0000\u0000\u0167\u0ca6"+ - "\u0001\u0000\u0000\u0000\u0169\u0cc2\u0001\u0000\u0000\u0000\u016b\u0cc6"+ - "\u0001\u0000\u0000\u0000\u016d\u0cd1\u0001\u0000\u0000\u0000\u016f\u0cd5"+ - "\u0001\u0000\u0000\u0000\u0171\u0cdd\u0001\u0000\u0000\u0000\u0173\u0ce5"+ - "\u0001\u0000\u0000\u0000\u0175\u0ced\u0001\u0000\u0000\u0000\u0177\u0cf6"+ - "\u0001\u0000\u0000\u0000\u0179\u0d00\u0001\u0000\u0000\u0000\u017b\u0d0b"+ - "\u0001\u0000\u0000\u0000\u017d\u0d14\u0001\u0000\u0000\u0000\u017f\u0d1c"+ - "\u0001\u0000\u0000\u0000\u0181\u0d24\u0001\u0000\u0000\u0000\u0183\u0d2b"+ - "\u0001\u0000\u0000\u0000\u0185\u0d32\u0001\u0000\u0000\u0000\u0187\u0d3c"+ - "\u0001\u0000\u0000\u0000\u0189\u0d47\u0001\u0000\u0000\u0000\u018b\u0d52"+ - "\u0001\u0000\u0000\u0000\u018d\u0d5a\u0001\u0000\u0000\u0000\u018f\u0d60"+ - "\u0001\u0000\u0000\u0000\u0191\u0d66\u0001\u0000\u0000\u0000\u0193\u0d6e"+ - "\u0001\u0000\u0000\u0000\u0195\u0d73\u0001\u0000\u0000\u0000\u0197\u0d7c"+ - "\u0001\u0000\u0000\u0000\u0199\u0d87\u0001\u0000\u0000\u0000\u019b\u0d8f"+ - "\u0001\u0000\u0000\u0000\u019d\u0d9a\u0001\u0000\u0000\u0000\u019f\u0da8"+ - "\u0001\u0000\u0000\u0000\u01a1\u0db4\u0001\u0000\u0000\u0000\u01a3\u0dbf"+ - "\u0001\u0000\u0000\u0000\u01a5\u0dc7\u0001\u0000\u0000\u0000\u01a7\u0ddd"+ - "\u0001\u0000\u0000\u0000\u01a9\u0de5\u0001\u0000\u0000\u0000\u01ab\u0df0"+ - "\u0001\u0000\u0000\u0000\u01ad\u0df9\u0001\u0000\u0000\u0000\u01af\u0e02"+ - "\u0001\u0000\u0000\u0000\u01b1\u0e05\u0001\u0000\u0000\u0000\u01b3\u0e0c"+ - "\u0001\u0000\u0000\u0000\u01b5\u0e13\u0001\u0000\u0000\u0000\u01b7\u0e18"+ - "\u0001\u0000\u0000\u0000\u01b9\u0e20\u0001\u0000\u0000\u0000\u01bb\u0e31"+ - "\u0001\u0000\u0000\u0000\u01bd\u0e47\u0001\u0000\u0000\u0000\u01bf\u0e4c"+ - "\u0001\u0000\u0000\u0000\u01c1\u0e54\u0001\u0000\u0000\u0000\u01c3\u0e59"+ - "\u0001\u0000\u0000\u0000\u01c5\u0e60\u0001\u0000\u0000\u0000\u01c7\u0e69"+ - "\u0001\u0000\u0000\u0000\u01c9\u0e73\u0001\u0000\u0000\u0000\u01cb\u0e77"+ - "\u0001\u0000\u0000\u0000\u01cd\u0e80\u0001\u0000\u0000\u0000\u01cf\u0e87"+ - "\u0001\u0000\u0000\u0000\u01d1\u0e8e\u0001\u0000\u0000\u0000\u01d3\u0e94"+ - "\u0001\u0000\u0000\u0000\u01d5\u0e9b\u0001\u0000\u0000\u0000\u01d7\u0ea5"+ - "\u0001\u0000\u0000\u0000\u01d9\u0ead\u0001\u0000\u0000\u0000\u01db\u0eb7"+ - "\u0001\u0000\u0000\u0000\u01dd\u0ec1\u0001\u0000\u0000\u0000\u01df\u0ec6"+ - "\u0001\u0000\u0000\u0000\u01e1\u0ece\u0001\u0000\u0000\u0000\u01e3\u0ed7"+ - "\u0001\u0000\u0000\u0000\u01e5\u0ede\u0001\u0000\u0000\u0000\u01e7\u0ee2"+ - "\u0001\u0000\u0000\u0000\u01e9\u0eea\u0001\u0000\u0000\u0000\u01eb\u0ef3"+ - "\u0001\u0000\u0000\u0000\u01ed\u0efd\u0001\u0000\u0000\u0000\u01ef\u0f06"+ - "\u0001\u0000\u0000\u0000\u01f1\u0f0e\u0001\u0000\u0000\u0000\u01f3\u0f14"+ - "\u0001\u0000\u0000\u0000\u01f5\u0f1a\u0001\u0000\u0000\u0000\u01f7\u0f21"+ - "\u0001\u0000\u0000\u0000\u01f9\u0f28\u0001\u0000\u0000\u0000\u01fb\u0f2e"+ - "\u0001\u0000\u0000\u0000\u01fd\u0f34\u0001\u0000\u0000\u0000\u01ff\u0f3a"+ - "\u0001\u0000\u0000\u0000\u0201\u0f40\u0001\u0000\u0000\u0000\u0203\u0f4a"+ - "\u0001\u0000\u0000\u0000\u0205\u0f4e\u0001\u0000\u0000\u0000\u0207\u0f54"+ - "\u0001\u0000\u0000\u0000\u0209\u0f5c\u0001\u0000\u0000\u0000\u020b\u0f63"+ - "\u0001\u0000\u0000\u0000\u020d\u0f6b\u0001\u0000\u0000\u0000\u020f\u0f73"+ - "\u0001\u0000\u0000\u0000\u0211\u0f79\u0001\u0000\u0000\u0000\u0213\u0f7e"+ - "\u0001\u0000\u0000\u0000\u0215\u0f85\u0001\u0000\u0000\u0000\u0217\u0f8a"+ - "\u0001\u0000\u0000\u0000\u0219\u0f8f\u0001\u0000\u0000\u0000\u021b\u0f98"+ - "\u0001\u0000\u0000\u0000\u021d\u0f9f\u0001\u0000\u0000\u0000\u021f\u0fa1"+ - "\u0001\u0000\u0000\u0000\u0221\u0fa9\u0001\u0000\u0000\u0000\u0223\u0fb3"+ - "\u0001\u0000\u0000\u0000\u0225\u0fb7\u0001\u0000\u0000\u0000\u0227\u0fbe"+ - "\u0001\u0000\u0000\u0000\u0229\u0fc1\u0001\u0000\u0000\u0000\u022b\u0fc6"+ - "\u0001\u0000\u0000\u0000\u022d\u0fcc\u0001\u0000\u0000\u0000\u022f\u0fd4"+ - "\u0001\u0000\u0000\u0000\u0231\u0fdd\u0001\u0000\u0000\u0000\u0233\u0fe3"+ - "\u0001\u0000\u0000\u0000\u0235\u0fec\u0001\u0000\u0000\u0000\u0237\u0ff4"+ - "\u0001\u0000\u0000\u0000\u0239\u0ffb\u0001\u0000\u0000\u0000\u023b\u1005"+ - "\u0001\u0000\u0000\u0000\u023d\u100a\u0001\u0000\u0000\u0000\u023f\u100f"+ - "\u0001\u0000\u0000\u0000\u0241\u1014\u0001\u0000\u0000\u0000\u0243\u101d"+ - "\u0001\u0000\u0000\u0000\u0245\u1024\u0001\u0000\u0000\u0000\u0247\u102a"+ - "\u0001\u0000\u0000\u0000\u0249\u1034\u0001\u0000\u0000\u0000\u024b\u103e"+ - "\u0001\u0000\u0000\u0000\u024d\u104d\u0001\u0000\u0000\u0000\u024f\u1056"+ - "\u0001\u0000\u0000\u0000\u0251\u1059\u0001\u0000\u0000\u0000\u0253\u1063"+ - "\u0001\u0000\u0000\u0000\u0255\u106d\u0001\u0000\u0000\u0000\u0257\u1073"+ - "\u0001\u0000\u0000\u0000\u0259\u107d\u0001\u0000\u0000\u0000\u025b\u1083"+ - "\u0001\u0000\u0000\u0000\u025d\u108c\u0001\u0000\u0000\u0000\u025f\u1097"+ - "\u0001\u0000\u0000\u0000\u0261\u10a1\u0001\u0000\u0000\u0000\u0263\u10a7"+ - "\u0001\u0000\u0000\u0000\u0265\u10ad\u0001\u0000\u0000\u0000\u0267\u10b3"+ - "\u0001\u0000\u0000\u0000\u0269\u10bf\u0001\u0000\u0000\u0000\u026b\u10c6"+ - "\u0001\u0000\u0000\u0000\u026d\u10cf\u0001\u0000\u0000\u0000\u026f\u10dc"+ - "\u0001\u0000\u0000\u0000\u0271\u10e4\u0001\u0000\u0000\u0000\u0273\u10e8"+ - "\u0001\u0000\u0000\u0000\u0275\u10f0\u0001\u0000\u0000\u0000\u0277\u10fa"+ - "\u0001\u0000\u0000\u0000\u0279\u1107\u0001\u0000\u0000\u0000\u027b\u1110"+ - "\u0001\u0000\u0000\u0000\u027d\u1115\u0001\u0000\u0000\u0000\u027f\u111d"+ - "\u0001\u0000\u0000\u0000\u0281\u1120\u0001\u0000\u0000\u0000\u0283\u112a"+ - "\u0001\u0000\u0000\u0000\u0285\u1132\u0001\u0000\u0000\u0000\u0287\u1137"+ - "\u0001\u0000\u0000\u0000\u0289\u1139\u0001\u0000\u0000\u0000\u028b\u113d"+ - "\u0001\u0000\u0000\u0000\u028d\u1148\u0001\u0000\u0000\u0000\u028f\u1151"+ - "\u0001\u0000\u0000\u0000\u0291\u1157\u0001\u0000\u0000\u0000\u0293\u1163"+ - "\u0001\u0000\u0000\u0000\u0295\u116c\u0001\u0000\u0000\u0000\u0297\u1172"+ - "\u0001\u0000\u0000\u0000\u0299\u1177\u0001\u0000\u0000\u0000\u029b\u117f"+ - "\u0001\u0000\u0000\u0000\u029d\u1187\u0001\u0000\u0000\u0000\u029f\u118d"+ - "\u0001\u0000\u0000\u0000\u02a1\u1192\u0001\u0000\u0000\u0000\u02a3\u1199"+ - "\u0001\u0000\u0000\u0000\u02a5\u119e\u0001\u0000\u0000\u0000\u02a7\u11a4"+ - "\u0001\u0000\u0000\u0000\u02a9\u11a9\u0001\u0000\u0000\u0000\u02ab\u11af"+ - "\u0001\u0000\u0000\u0000\u02ad\u11b6\u0001\u0000\u0000\u0000\u02af\u11b9"+ - "\u0001\u0000\u0000\u0000\u02b1\u11be\u0001\u0000\u0000\u0000\u02b3\u11c4"+ - "\u0001\u0000\u0000\u0000\u02b5\u11ce\u0001\u0000\u0000\u0000\u02b7\u11dd"+ - "\u0001\u0000\u0000\u0000\u02b9\u11e6\u0001\u0000\u0000\u0000\u02bb\u11ee"+ - "\u0001\u0000\u0000\u0000\u02bd\u11f3\u0001\u0000\u0000\u0000\u02bf\u11fa"+ - "\u0001\u0000\u0000\u0000\u02c1\u1200\u0001\u0000\u0000\u0000\u02c3\u1202"+ - "\u0001\u0000\u0000\u0000\u02c5\u1207\u0001\u0000\u0000\u0000\u02c7\u120b"+ - "\u0001\u0000\u0000\u0000\u02c9\u1213\u0001\u0000\u0000\u0000\u02cb\u1219"+ - "\u0001\u0000\u0000\u0000\u02cd\u1226\u0001\u0000\u0000\u0000\u02cf\u122e"+ - "\u0001\u0000\u0000\u0000\u02d1\u1232\u0001\u0000\u0000\u0000\u02d3\u123b"+ - "\u0001\u0000\u0000\u0000\u02d5\u1242\u0001\u0000\u0000\u0000\u02d7\u1248"+ - "\u0001\u0000\u0000\u0000\u02d9\u1257\u0001\u0000\u0000\u0000\u02db\u126c"+ - "\u0001\u0000\u0000\u0000\u02dd\u1279\u0001\u0000\u0000\u0000\u02df\u1280"+ - "\u0001\u0000\u0000\u0000\u02e1\u1284\u0001\u0000\u0000\u0000\u02e3\u128b"+ - "\u0001\u0000\u0000\u0000\u02e5\u1294\u0001\u0000\u0000\u0000\u02e7\u1298"+ - "\u0001\u0000\u0000\u0000\u02e9\u129d\u0001\u0000\u0000\u0000\u02eb\u12a6"+ - "\u0001\u0000\u0000\u0000\u02ed\u12ad\u0001\u0000\u0000\u0000\u02ef\u12b4"+ - "\u0001\u0000\u0000\u0000\u02f1\u12ba\u0001\u0000\u0000\u0000\u02f3\u12bf"+ - "\u0001\u0000\u0000\u0000\u02f5\u12c4\u0001\u0000\u0000\u0000\u02f7\u12cd"+ - "\u0001\u0000\u0000\u0000\u02f9\u12d3\u0001\u0000\u0000\u0000\u02fb\u12d8"+ - "\u0001\u0000\u0000\u0000\u02fd\u12de\u0001\u0000\u0000\u0000\u02ff\u12e7"+ - "\u0001\u0000\u0000\u0000\u0301\u12ef\u0001\u0000\u0000\u0000\u0303\u12f5"+ - "\u0001\u0000\u0000\u0000\u0305\u12fb\u0001\u0000\u0000\u0000\u0307\u1303"+ - "\u0001\u0000\u0000\u0000\u0309\u1307\u0001\u0000\u0000\u0000\u030b\u130c"+ - "\u0001\u0000\u0000\u0000\u030d\u130f\u0001\u0000\u0000\u0000\u030f\u131a"+ - "\u0001\u0000\u0000\u0000\u0311\u1327\u0001\u0000\u0000\u0000\u0313\u132c"+ - "\u0001\u0000\u0000\u0000\u0315\u1336\u0001\u0000\u0000\u0000\u0317\u1341"+ - "\u0001\u0000\u0000\u0000\u0319\u1345\u0001\u0000\u0000\u0000\u031b\u134d"+ - "\u0001\u0000\u0000\u0000\u031d\u1354\u0001\u0000\u0000\u0000\u031f\u135c"+ - "\u0001\u0000\u0000\u0000\u0321\u1363\u0001\u0000\u0000\u0000\u0323\u1368"+ - "\u0001\u0000\u0000\u0000\u0325\u1371\u0001\u0000\u0000\u0000\u0327\u1378"+ - "\u0001\u0000\u0000\u0000\u0329\u137e\u0001\u0000\u0000\u0000\u032b\u1385"+ - "\u0001\u0000\u0000\u0000\u032d\u138d\u0001\u0000\u0000\u0000\u032f\u1394"+ - "\u0001\u0000\u0000\u0000\u0331\u13a1\u0001\u0000\u0000\u0000\u0333\u13a8"+ - "\u0001\u0000\u0000\u0000\u0335\u13ab\u0001\u0000\u0000\u0000\u0337\u13af"+ - "\u0001\u0000\u0000\u0000\u0339\u13b6\u0001\u0000\u0000\u0000\u033b\u13bb"+ - "\u0001\u0000\u0000\u0000\u033d\u13bf\u0001\u0000\u0000\u0000\u033f\u13c2"+ - "\u0001\u0000\u0000\u0000\u0341\u13c7\u0001\u0000\u0000\u0000\u0343\u13cc"+ - "\u0001\u0000\u0000\u0000\u0345\u13d6\u0001\u0000\u0000\u0000\u0347\u13df"+ - "\u0001\u0000\u0000\u0000\u0349\u13e6\u0001\u0000\u0000\u0000\u034b\u13ee"+ - "\u0001\u0000\u0000\u0000\u034d\u13f1\u0001\u0000\u0000\u0000\u034f\u13f7"+ - "\u0001\u0000\u0000\u0000\u0351\u1400\u0001\u0000\u0000\u0000\u0353\u140b"+ - "\u0001\u0000\u0000\u0000\u0355\u1412\u0001\u0000\u0000\u0000\u0357\u1416"+ - "\u0001\u0000\u0000\u0000\u0359\u141c\u0001\u0000\u0000\u0000\u035b\u1423"+ - "\u0001\u0000\u0000\u0000\u035d\u1428\u0001\u0000\u0000\u0000\u035f\u1431"+ - "\u0001\u0000\u0000\u0000\u0361\u1439\u0001\u0000\u0000\u0000\u0363\u1444"+ - "\u0001\u0000\u0000\u0000\u0365\u144a\u0001\u0000\u0000\u0000\u0367\u144e"+ - "\u0001\u0000\u0000\u0000\u0369\u1458\u0001\u0000\u0000\u0000\u036b\u1467"+ - "\u0001\u0000\u0000\u0000\u036d\u1476\u0001\u0000\u0000\u0000\u036f\u1491"+ - "\u0001\u0000\u0000\u0000\u0371\u14ac\u0001\u0000\u0000\u0000\u0373\u14c4"+ - "\u0001\u0000\u0000\u0000\u0375\u14de\u0001\u0000\u0000\u0000\u0377\u14e9"+ - "\u0001\u0000\u0000\u0000\u0379\u14f0\u0001\u0000\u0000\u0000\u037b\u14f8"+ - "\u0001\u0000\u0000\u0000\u037d\u1502\u0001\u0000\u0000\u0000\u037f\u1509"+ - "\u0001\u0000\u0000\u0000\u0381\u1512\u0001\u0000\u0000\u0000\u0383\u1517"+ - "\u0001\u0000\u0000\u0000\u0385\u1524\u0001\u0000\u0000\u0000\u0387\u1534"+ - "\u0001\u0000\u0000\u0000\u0389\u1544\u0001\u0000\u0000\u0000\u038b\u154c"+ - "\u0001\u0000\u0000\u0000\u038d\u1552\u0001\u0000\u0000\u0000\u038f\u1558"+ - "\u0001\u0000\u0000\u0000\u0391\u155c\u0001\u0000\u0000\u0000\u0393\u1565"+ - "\u0001\u0000\u0000\u0000\u0395\u156d\u0001\u0000\u0000\u0000\u0397\u1573"+ - "\u0001\u0000\u0000\u0000\u0399\u157d\u0001\u0000\u0000\u0000\u039b\u1587"+ - "\u0001\u0000\u0000\u0000\u039d\u158e\u0001\u0000\u0000\u0000\u039f\u1597"+ - "\u0001\u0000\u0000\u0000\u03a1\u159f\u0001\u0000\u0000\u0000\u03a3\u15a8"+ - "\u0001\u0000\u0000\u0000\u03a5\u15b1\u0001\u0000\u0000\u0000\u03a7\u15b9"+ - "\u0001\u0000\u0000\u0000\u03a9\u15bf\u0001\u0000\u0000\u0000\u03ab\u15ca"+ - "\u0001\u0000\u0000\u0000\u03ad\u15d5\u0001\u0000\u0000\u0000\u03af\u15df"+ - "\u0001\u0000\u0000\u0000\u03b1\u15e6\u0001\u0000\u0000\u0000\u03b3\u15f2"+ - "\u0001\u0000\u0000\u0000\u03b5\u15f8\u0001\u0000\u0000\u0000\u03b7\u15fe"+ - "\u0001\u0000\u0000\u0000\u03b9\u1603\u0001\u0000\u0000\u0000\u03bb\u1608"+ - "\u0001\u0000\u0000\u0000\u03bd\u160e\u0001\u0000\u0000\u0000\u03bf\u1613"+ - "\u0001\u0000\u0000\u0000\u03c1\u161c\u0001\u0000\u0000\u0000\u03c3\u1624"+ - "\u0001\u0000\u0000\u0000\u03c5\u162e\u0001\u0000\u0000\u0000\u03c7\u1632"+ - "\u0001\u0000\u0000\u0000\u03c9\u163d\u0001\u0000\u0000\u0000\u03cb\u1649"+ - "\u0001\u0000\u0000\u0000\u03cd\u1651\u0001\u0000\u0000\u0000\u03cf\u165b"+ - "\u0001\u0000\u0000\u0000\u03d1\u1665\u0001\u0000\u0000\u0000\u03d3\u1670"+ - "\u0001\u0000\u0000\u0000\u03d5\u167f\u0001\u0000\u0000\u0000\u03d7\u1687"+ - "\u0001\u0000\u0000\u0000\u03d9\u1692\u0001\u0000\u0000\u0000\u03db\u169b"+ - "\u0001\u0000\u0000\u0000\u03dd\u16a4\u0001\u0000\u0000\u0000\u03df\u16ad"+ - "\u0001\u0000\u0000\u0000\u03e1\u16b5\u0001\u0000\u0000\u0000\u03e3\u16be"+ - "\u0001\u0000\u0000\u0000\u03e5\u16c6\u0001\u0000\u0000\u0000\u03e7\u16cd"+ - "\u0001\u0000\u0000\u0000\u03e9\u16d8\u0001\u0000\u0000\u0000\u03eb\u16e0"+ - "\u0001\u0000\u0000\u0000\u03ed\u16e8\u0001\u0000\u0000\u0000\u03ef\u16ee"+ - "\u0001\u0000\u0000\u0000\u03f1\u16f6\u0001\u0000\u0000\u0000\u03f3\u16ff"+ - "\u0001\u0000\u0000\u0000\u03f5\u1706\u0001\u0000\u0000\u0000\u03f7\u170d"+ - "\u0001\u0000\u0000\u0000\u03f9\u1722\u0001\u0000\u0000\u0000\u03fb\u1732"+ - "\u0001\u0000\u0000\u0000\u03fd\u1748\u0001\u0000\u0000\u0000\u03ff\u175a"+ - "\u0001\u0000\u0000\u0000\u0401\u1764\u0001\u0000\u0000\u0000\u0403\u176c"+ - "\u0001\u0000\u0000\u0000\u0405\u1773\u0001\u0000\u0000\u0000\u0407\u1779"+ - "\u0001\u0000\u0000\u0000\u0409\u177e\u0001\u0000\u0000\u0000\u040b\u1787"+ - "\u0001\u0000\u0000\u0000\u040d\u178e\u0001\u0000\u0000\u0000\u040f\u1796"+ - "\u0001\u0000\u0000\u0000\u0411\u17a6\u0001\u0000\u0000\u0000\u0413\u17b3"+ - "\u0001\u0000\u0000\u0000\u0415\u17c2\u0001\u0000\u0000\u0000\u0417\u17c6"+ - "\u0001\u0000\u0000\u0000\u0419\u17d0\u0001\u0000\u0000\u0000\u041b\u17db"+ - "\u0001\u0000\u0000\u0000\u041d\u17e0\u0001\u0000\u0000\u0000\u041f\u17e5"+ - "\u0001\u0000\u0000\u0000\u0421\u17ef\u0001\u0000\u0000\u0000\u0423\u17f5"+ - "\u0001\u0000\u0000\u0000\u0425\u17fc\u0001\u0000\u0000\u0000\u0427\u1808"+ - "\u0001\u0000\u0000\u0000\u0429\u180e\u0001\u0000\u0000\u0000\u042b\u181c"+ - "\u0001\u0000\u0000\u0000\u042d\u1827\u0001\u0000\u0000\u0000\u042f\u1834"+ - "\u0001\u0000\u0000\u0000\u0431\u183b\u0001\u0000\u0000\u0000\u0433\u1842"+ - "\u0001\u0000\u0000\u0000\u0435\u1849\u0001\u0000\u0000\u0000\u0437\u1851"+ - "\u0001\u0000\u0000\u0000\u0439\u185a\u0001\u0000\u0000\u0000\u043b\u1861"+ - "\u0001\u0000\u0000\u0000\u043d\u1866\u0001\u0000\u0000\u0000\u043f\u1870"+ - "\u0001\u0000\u0000\u0000\u0441\u1879\u0001\u0000\u0000\u0000\u0443\u1883"+ - "\u0001\u0000\u0000\u0000\u0445\u1890\u0001\u0000\u0000\u0000\u0447\u189c"+ - "\u0001\u0000\u0000\u0000\u0449\u18a4\u0001\u0000\u0000\u0000\u044b\u18b1"+ - "\u0001\u0000\u0000\u0000\u044d\u18b5\u0001\u0000\u0000\u0000\u044f\u18bb"+ - "\u0001\u0000\u0000\u0000\u0451\u18c0\u0001\u0000\u0000\u0000\u0453\u18c6"+ - "\u0001\u0000\u0000\u0000\u0455\u18cb\u0001\u0000\u0000\u0000\u0457\u18d3"+ - "\u0001\u0000\u0000\u0000\u0459\u18da\u0001\u0000\u0000\u0000\u045b\u18df"+ - "\u0001\u0000\u0000\u0000\u045d\u18e4\u0001\u0000\u0000\u0000\u045f\u18ed"+ - "\u0001\u0000\u0000\u0000\u0461\u18f6\u0001\u0000\u0000\u0000\u0463\u18fb"+ - "\u0001\u0000\u0000\u0000\u0465\u1902\u0001\u0000\u0000\u0000\u0467\u1908"+ - "\u0001\u0000\u0000\u0000\u0469\u1911\u0001\u0000\u0000\u0000\u046b\u191f"+ - "\u0001\u0000\u0000\u0000\u046d\u192c\u0001\u0000\u0000\u0000\u046f\u1930"+ - "\u0001\u0000\u0000\u0000\u0471\u1938\u0001\u0000\u0000\u0000\u0473\u1941"+ - "\u0001\u0000\u0000\u0000\u0475\u194e\u0001\u0000\u0000\u0000\u0477\u1957"+ - "\u0001\u0000\u0000\u0000\u0479\u1962\u0001\u0000\u0000\u0000\u047b\u1967"+ - "\u0001\u0000\u0000\u0000\u047d\u196e\u0001\u0000\u0000\u0000\u047f\u1974"+ - "\u0001\u0000\u0000\u0000\u0481\u197a\u0001\u0000\u0000\u0000\u0483\u1984"+ - "\u0001\u0000\u0000\u0000\u0485\u198b\u0001\u0000\u0000\u0000\u0487\u1996"+ - "\u0001\u0000\u0000\u0000\u0489\u19a1\u0001\u0000\u0000\u0000\u048b\u19ad"+ - "\u0001\u0000\u0000\u0000\u048d\u19b3\u0001\u0000\u0000\u0000\u048f\u19ba"+ - "\u0001\u0000\u0000\u0000\u0491\u19c2\u0001\u0000\u0000\u0000\u0493\u19c9"+ - "\u0001\u0000\u0000\u0000\u0495\u19d3\u0001\u0000\u0000\u0000\u0497\u19d9"+ - "\u0001\u0000\u0000\u0000\u0499\u19e9\u0001\u0000\u0000\u0000\u049b\u19f1"+ - "\u0001\u0000\u0000\u0000\u049d\u19fd\u0001\u0000\u0000\u0000\u049f\u1a0a"+ - "\u0001\u0000\u0000\u0000\u04a1\u1a14\u0001\u0000\u0000\u0000\u04a3\u1a18"+ - "\u0001\u0000\u0000\u0000\u04a5\u1a22\u0001\u0000\u0000\u0000\u04a7\u1a28"+ - "\u0001\u0000\u0000\u0000\u04a9\u1a2f\u0001\u0000\u0000\u0000\u04ab\u1a3b"+ - "\u0001\u0000\u0000\u0000\u04ad\u1a41\u0001\u0000\u0000\u0000\u04af\u1a4c"+ - "\u0001\u0000\u0000\u0000\u04b1\u1a58\u0001\u0000\u0000\u0000\u04b3\u1a63"+ - "\u0001\u0000\u0000\u0000\u04b5\u1a68\u0001\u0000\u0000\u0000\u04b7\u1a71"+ - "\u0001\u0000\u0000\u0000\u04b9\u1a7b\u0001\u0000\u0000\u0000\u04bb\u1a85"+ - "\u0001\u0000\u0000\u0000\u04bd\u1a8a\u0001\u0000\u0000\u0000\u04bf\u1a8f"+ - "\u0001\u0000\u0000\u0000\u04c1\u1a94\u0001\u0000\u0000\u0000\u04c3\u1a99"+ - "\u0001\u0000\u0000\u0000\u04c5\u1aa3\u0001\u0000\u0000\u0000\u04c7\u1ab1"+ - "\u0001\u0000\u0000\u0000\u04c9\u1ac1\u0001\u0000\u0000\u0000\u04cb\u1ac8"+ - "\u0001\u0000\u0000\u0000\u04cd\u1acb\u0001\u0000\u0000\u0000\u04cf\u1ad1"+ - "\u0001\u0000\u0000\u0000\u04d1\u1ad5\u0001\u0000\u0000\u0000\u04d3\u1ae5"+ - "\u0001\u0000\u0000\u0000\u04d5\u1aee\u0001\u0000\u0000\u0000\u04d7\u1afa"+ - "\u0001\u0000\u0000\u0000\u04d9\u1b0d\u0001\u0000\u0000\u0000\u04db\u1b24"+ - "\u0001\u0000\u0000\u0000\u04dd\u1b3d\u0001\u0000\u0000\u0000\u04df\u1b47"+ - "\u0001\u0000\u0000\u0000\u04e1\u1b52\u0001\u0000\u0000\u0000\u04e3\u1b5c"+ - "\u0001\u0000\u0000\u0000\u04e5\u1b68\u0001\u0000\u0000\u0000\u04e7\u1b6e"+ - "\u0001\u0000\u0000\u0000\u04e9\u1b76\u0001\u0000\u0000\u0000\u04eb\u1b86"+ - "\u0001\u0000\u0000\u0000\u04ed\u1b93\u0001\u0000\u0000\u0000\u04ef\u1ba2"+ - "\u0001\u0000\u0000\u0000\u04f1\u1ba7\u0001\u0000\u0000\u0000\u04f3\u1bac"+ - "\u0001\u0000\u0000\u0000\u04f5\u1bb5\u0001\u0000\u0000\u0000\u04f7\u1bbd"+ - "\u0001\u0000\u0000\u0000\u04f9\u1bc2\u0001\u0000\u0000\u0000\u04fb\u1bca"+ - "\u0001\u0000\u0000\u0000\u04fd\u1bd4\u0001\u0000\u0000\u0000\u04ff\u1be0"+ - "\u0001\u0000\u0000\u0000\u0501\u1be6\u0001\u0000\u0000\u0000\u0503\u1bf2"+ - "\u0001\u0000\u0000\u0000\u0505\u1bf8\u0001\u0000\u0000\u0000\u0507\u1bff"+ - "\u0001\u0000\u0000\u0000\u0509\u1c07\u0001\u0000\u0000\u0000\u050b\u1c10"+ - "\u0001\u0000\u0000\u0000\u050d\u1c19\u0001\u0000\u0000\u0000\u050f\u1c21"+ - "\u0001\u0000\u0000\u0000\u0511\u1c28\u0001\u0000\u0000\u0000\u0513\u1c2e"+ - "\u0001\u0000\u0000\u0000\u0515\u1c35\u0001\u0000\u0000\u0000\u0517\u1c3b"+ - "\u0001\u0000\u0000\u0000\u0519\u1c41\u0001\u0000\u0000\u0000\u051b\u1c46"+ - "\u0001\u0000\u0000\u0000\u051d\u1c60\u0001\u0000\u0000\u0000\u051f\u1c77"+ - "\u0001\u0000\u0000\u0000\u0521\u1c8e\u0001\u0000\u0000\u0000\u0523\u1ca7"+ - "\u0001\u0000\u0000\u0000\u0525\u1cad\u0001\u0000\u0000\u0000\u0527\u1cb4"+ - "\u0001\u0000\u0000\u0000\u0529\u1cba\u0001\u0000\u0000\u0000\u052b\u1cc3"+ - "\u0001\u0000\u0000\u0000\u052d\u1ccd\u0001\u0000\u0000\u0000\u052f\u1cd3"+ - "\u0001\u0000\u0000\u0000\u0531\u1cda\u0001\u0000\u0000\u0000\u0533\u1ce2"+ - "\u0001\u0000\u0000\u0000\u0535\u1ceb\u0001\u0000\u0000\u0000\u0537\u1cf3"+ - "\u0001\u0000\u0000\u0000\u0539\u1cfc\u0001\u0000\u0000\u0000\u053b\u1d05"+ - "\u0001\u0000\u0000\u0000\u053d\u1d0d\u0001\u0000\u0000\u0000\u053f\u1d15"+ - "\u0001\u0000\u0000\u0000\u0541\u1d1a\u0001\u0000\u0000\u0000\u0543\u1d23"+ - "\u0001\u0000\u0000\u0000\u0545\u1d28\u0001\u0000\u0000\u0000\u0547\u1d31"+ - "\u0001\u0000\u0000\u0000\u0549\u1d37\u0001\u0000\u0000\u0000\u054b\u1d44"+ - "\u0001\u0000\u0000\u0000\u054d\u1d4b\u0001\u0000\u0000\u0000\u054f\u1d50"+ - "\u0001\u0000\u0000\u0000\u0551\u1d57\u0001\u0000\u0000\u0000\u0553\u1d5f"+ - "\u0001\u0000\u0000\u0000\u0555\u1d64\u0001\u0000\u0000\u0000\u0557\u1d6a"+ - "\u0001\u0000\u0000\u0000\u0559\u1d6f\u0001\u0000\u0000\u0000\u055b\u1d74"+ - "\u0001\u0000\u0000\u0000\u055d\u1d78\u0001\u0000\u0000\u0000\u055f\u1d7d"+ - "\u0001\u0000\u0000\u0000\u0561\u1d87\u0001\u0000\u0000\u0000\u0563\u1d93"+ - "\u0001\u0000\u0000\u0000\u0565\u1d9e\u0001\u0000\u0000\u0000\u0567\u1dab"+ - "\u0001\u0000\u0000\u0000\u0569\u1db3\u0001\u0000\u0000\u0000\u056b\u1dbd"+ - "\u0001\u0000\u0000\u0000\u056d\u1dc3\u0001\u0000\u0000\u0000\u056f\u1dcb"+ - "\u0001\u0000\u0000\u0000\u0571\u1dd7\u0001\u0000\u0000\u0000\u0573\u1de5"+ - "\u0001\u0000\u0000\u0000\u0575\u1def\u0001\u0000\u0000\u0000\u0577\u1dfb"+ - "\u0001\u0000\u0000\u0000\u0579\u1e01\u0001\u0000\u0000\u0000\u057b\u1e07"+ - "\u0001\u0000\u0000\u0000\u057d\u1e0e\u0001\u0000\u0000\u0000\u057f\u1e18"+ - "\u0001\u0000\u0000\u0000\u0581\u1e28\u0001\u0000\u0000\u0000\u0583\u1e34"+ - "\u0001\u0000\u0000\u0000\u0585\u1e3f\u0001\u0000\u0000\u0000\u0587\u1e4c"+ - "\u0001\u0000\u0000\u0000\u0589\u1e55\u0001\u0000\u0000\u0000\u058b\u1e5c"+ - "\u0001\u0000\u0000\u0000\u058d\u1e65\u0001\u0000\u0000\u0000\u058f\u1e6c"+ - "\u0001\u0000\u0000\u0000\u0591\u1e74\u0001\u0000\u0000\u0000\u0593\u1e7f"+ - "\u0001\u0000\u0000\u0000\u0595\u1e90\u0001\u0000\u0000\u0000\u0597\u1e9a"+ - "\u0001\u0000\u0000\u0000\u0599\u1ea1\u0001\u0000\u0000\u0000\u059b\u1eaa"+ - "\u0001\u0000\u0000\u0000\u059d\u1eb7\u0001\u0000\u0000\u0000\u059f\u1ebc"+ - "\u0001\u0000\u0000\u0000\u05a1\u1ec7\u0001\u0000\u0000\u0000\u05a3\u1ece"+ - "\u0001\u0000\u0000\u0000\u05a5\u1ed7\u0001\u0000\u0000\u0000\u05a7\u1eda"+ - "\u0001\u0000\u0000\u0000\u05a9\u1ee1\u0001\u0000\u0000\u0000\u05ab\u1eec"+ - "\u0001\u0000\u0000\u0000\u05ad\u1ef5\u0001\u0000\u0000\u0000\u05af\u1efe"+ - "\u0001\u0000\u0000\u0000\u05b1\u1f06\u0001\u0000\u0000\u0000\u05b3\u1f18"+ - "\u0001\u0000\u0000\u0000\u05b5\u1f24\u0001\u0000\u0000\u0000\u05b7\u1f2a"+ - "\u0001\u0000\u0000\u0000\u05b9\u1f32\u0001\u0000\u0000\u0000\u05bb\u1f39"+ - "\u0001\u0000\u0000\u0000\u05bd\u1f3f\u0001\u0000\u0000\u0000\u05bf\u1f44"+ - "\u0001\u0000\u0000\u0000\u05c1\u1f49\u0001\u0000\u0000\u0000\u05c3\u1f50"+ - "\u0001\u0000\u0000\u0000\u05c5\u1f54\u0001\u0000\u0000\u0000\u05c7\u1f59"+ - "\u0001\u0000\u0000\u0000\u05c9\u1f66\u0001\u0000\u0000\u0000\u05cb\u1f6d"+ - "\u0001\u0000\u0000\u0000\u05cd\u1f7a\u0001\u0000\u0000\u0000\u05cf\u1f82"+ - "\u0001\u0000\u0000\u0000\u05d1\u1f8b\u0001\u0000\u0000\u0000\u05d3\u1f96"+ - "\u0001\u0000\u0000\u0000\u05d5\u1f9e\u0001\u0000\u0000\u0000\u05d7\u1fa5"+ - "\u0001\u0000\u0000\u0000\u05d9\u1fac\u0001\u0000\u0000\u0000\u05db\u1fb3"+ - "\u0001\u0000\u0000\u0000\u05dd\u1fba\u0001\u0000\u0000\u0000\u05df\u1fc0"+ - "\u0001\u0000\u0000\u0000\u05e1\u1fc8\u0001\u0000\u0000\u0000\u05e3\u1fd2"+ - "\u0001\u0000\u0000\u0000\u05e5\u1fde\u0001\u0000\u0000\u0000\u05e7\u1fe3"+ - "\u0001\u0000\u0000\u0000\u05e9\u1fe7\u0001\u0000\u0000\u0000\u05eb\u1fed"+ - "\u0001\u0000\u0000\u0000\u05ed\u1fff\u0001\u0000\u0000\u0000\u05ef\u2004"+ - "\u0001\u0000\u0000\u0000\u05f1\u200b\u0001\u0000\u0000\u0000\u05f3\u2012"+ - "\u0001\u0000\u0000\u0000\u05f5\u2019\u0001\u0000\u0000\u0000\u05f7\u201e"+ - "\u0001\u0000\u0000\u0000\u05f9\u2023\u0001\u0000\u0000\u0000\u05fb\u2028"+ - "\u0001\u0000\u0000\u0000\u05fd\u202d\u0001\u0000\u0000\u0000\u05ff\u2032"+ - "\u0001\u0000\u0000\u0000\u0601\u2038\u0001\u0000\u0000\u0000\u0603\u203d"+ - "\u0001\u0000\u0000\u0000\u0605\u2042\u0001\u0000\u0000\u0000\u0607\u204a"+ - "\u0001\u0000\u0000\u0000\u0609\u2053\u0001\u0000\u0000\u0000\u060b\u2059"+ - "\u0001\u0000\u0000\u0000\u060d\u2060\u0001\u0000\u0000\u0000\u060f\u2066"+ - "\u0001\u0000\u0000\u0000\u0611\u206e\u0001\u0000\u0000\u0000\u0613\u2076"+ - "\u0001\u0000\u0000\u0000\u0615\u207d\u0001\u0000\u0000\u0000\u0617\u2085"+ - "\u0001\u0000\u0000\u0000\u0619\u208d\u0001\u0000\u0000\u0000\u061b\u2095"+ - "\u0001\u0000\u0000\u0000\u061d\u20a1\u0001\u0000\u0000\u0000\u061f\u20a8"+ - "\u0001\u0000\u0000\u0000\u0621\u20ad\u0001\u0000\u0000\u0000\u0623\u20b9"+ - "\u0001\u0000\u0000\u0000\u0625\u20c0\u0001\u0000\u0000\u0000\u0627\u20c8"+ - "\u0001\u0000\u0000\u0000\u0629\u20d1\u0001\u0000\u0000\u0000\u062b\u20df"+ - "\u0001\u0000\u0000\u0000\u062d\u20e4\u0001\u0000\u0000\u0000\u062f\u20eb"+ - "\u0001\u0000\u0000\u0000\u0631\u20ef\u0001\u0000\u0000\u0000\u0633\u20f1"+ - "\u0001\u0000\u0000\u0000\u0635\u20f3\u0001\u0000\u0000\u0000\u0637\u20f6"+ - "\u0001\u0000\u0000\u0000\u0639\u20f8\u0001\u0000\u0000\u0000\u063b\u20fb"+ - "\u0001\u0000\u0000\u0000\u063d\u20fd\u0001\u0000\u0000\u0000\u063f\u20ff"+ - "\u0001\u0000\u0000\u0000\u0641\u2101\u0001\u0000\u0000\u0000\u0643\u2103"+ - "\u0001\u0000\u0000\u0000\u0645\u2105\u0001\u0000\u0000\u0000\u0647\u210f"+ - "\u0001\u0000\u0000\u0000\u0649\u2113\u0001\u0000\u0000\u0000\u064b\u212f"+ - "\u0001\u0000\u0000\u0000\u064d\u213e\u0001\u0000\u0000\u0000\u064f\u2141"+ - "\u0001\u0000\u0000\u0000\u0651\u2143\u0001\u0000\u0000\u0000\u0653\u2145"+ - "\u0001\u0000\u0000\u0000\u0655\u2147\u0001\u0000\u0000\u0000\u0657\u214e"+ - "\u0001\u0000\u0000\u0000\u0659\u2154\u0001\u0000\u0000\u0000\u065b\u215b"+ - "\u0001\u0000\u0000\u0000\u065d\u215d\u0001\u0000\u0000\u0000\u065f\u2160"+ - "\u0001\u0000\u0000\u0000\u0661\u2163\u0001\u0000\u0000\u0000\u0663\u2166"+ - "\u0001\u0000\u0000\u0000\u0665\u2169\u0001\u0000\u0000\u0000\u0667\u216b"+ - "\u0001\u0000\u0000\u0000\u0669\u216d\u0001\u0000\u0000\u0000\u066b\u2170"+ - "\u0001\u0000\u0000\u0000\u066d\u2173\u0001\u0000\u0000\u0000\u066f\u2175"+ - "\u0001\u0000\u0000\u0000\u0671\u2177\u0001\u0000\u0000\u0000\u0673\u217a"+ - "\u0001\u0000\u0000\u0000\u0675\u217c\u0001\u0000\u0000\u0000\u0677\u217f"+ - "\u0001\u0000\u0000\u0000\u0679\u2182\u0001\u0000\u0000\u0000\u067b\u2184"+ - "\u0001\u0000\u0000\u0000\u067d\u2187\u0001\u0000\u0000\u0000\u067f\u218a"+ - "\u0001\u0000\u0000\u0000\u0681\u218e\u0001\u0000\u0000\u0000\u0683\u2191"+ - "\u0001\u0000\u0000\u0000\u0685\u2194\u0001\u0000\u0000\u0000\u0687\u2198"+ - "\u0001\u0000\u0000\u0000\u0689\u219c\u0001\u0000\u0000\u0000\u068b\u219e"+ - "\u0001\u0000\u0000\u0000\u068d\u21a1\u0001\u0000\u0000\u0000\u068f\u21a4"+ - "\u0001\u0000\u0000\u0000\u0691\u21a7\u0001\u0000\u0000\u0000\u0693\u21aa"+ - "\u0001\u0000\u0000\u0000\u0695\u21ae\u0001\u0000\u0000\u0000\u0697\u21b1"+ - "\u0001\u0000\u0000\u0000\u0699\u21b5\u0001\u0000\u0000\u0000\u069b\u21b9"+ - "\u0001\u0000\u0000\u0000\u069d\u21bb\u0001\u0000\u0000\u0000\u069f\u21bd"+ - "\u0001\u0000\u0000\u0000\u06a1\u21bf\u0001\u0000\u0000\u0000\u06a3\u21c2"+ - "\u0001\u0000\u0000\u0000\u06a5\u21c6\u0001\u0000\u0000\u0000\u06a7\u21c9"+ - "\u0001\u0000\u0000\u0000\u06a9\u21cb\u0001\u0000\u0000\u0000\u06ab\u21cd"+ - "\u0001\u0000\u0000\u0000\u06ad\u21d0\u0001\u0000\u0000\u0000\u06af\u21d3"+ - "\u0001\u0000\u0000\u0000\u06b1\u21d6\u0001\u0000\u0000\u0000\u06b3\u21d9"+ - "\u0001\u0000\u0000\u0000\u06b5\u21db\u0001\u0000\u0000\u0000\u06b7\u21dd"+ - "\u0001\u0000\u0000\u0000\u06b9\u21e0\u0001\u0000\u0000\u0000\u06bb\u21e5"+ - "\u0001\u0000\u0000\u0000\u06bd\u21e9\u0001\u0000\u0000\u0000\u06bf\u21ee"+ - "\u0001\u0000\u0000\u0000\u06c1\u21f2\u0001\u0000\u0000\u0000\u06c3\u21f5"+ - "\u0001\u0000\u0000\u0000\u06c5\u21f8\u0001\u0000\u0000\u0000\u06c7\u21fa"+ - "\u0001\u0000\u0000\u0000\u06c9\u2203\u0001\u0000\u0000\u0000\u06cb\u06cd"+ - "\u0007\u0000\u0000\u0000\u06cc\u06cb\u0001\u0000\u0000\u0000\u06cd\u06ce"+ - "\u0001\u0000\u0000\u0000\u06ce\u06cc\u0001\u0000\u0000\u0000\u06ce\u06cf"+ - "\u0001\u0000\u0000\u0000\u06cf\u06d0\u0001\u0000\u0000\u0000\u06d0\u06d1"+ - "\u0006\u0000\u0000\u0000\u06d1\u0002\u0001\u0000\u0000\u0000\u06d2\u06d3"+ - "\u0005/\u0000\u0000\u06d3\u06d4\u0005*\u0000\u0000\u06d4\u06d8\u0001\u0000"+ - "\u0000\u0000\u06d5\u06d7\t\u0000\u0000\u0000\u06d6\u06d5\u0001\u0000\u0000"+ - "\u0000\u06d7\u06da\u0001\u0000\u0000\u0000\u06d8\u06d9\u0001\u0000\u0000"+ - "\u0000\u06d8\u06d6\u0001\u0000\u0000\u0000\u06d9\u06db\u0001\u0000\u0000"+ - "\u0000\u06da\u06d8\u0001\u0000\u0000\u0000\u06db\u06dc\u0005*\u0000\u0000"+ - "\u06dc\u06dd\u0005/\u0000\u0000\u06dd\u06de\u0001\u0000\u0000\u0000\u06de"+ - "\u06df\u0006\u0001\u0001\u0000\u06df\u0004\u0001\u0000\u0000\u0000\u06e0"+ - "\u06e1\u0005-\u0000\u0000\u06e1\u06e2\u0005-\u0000\u0000\u06e2\u06e6\u0001"+ - "\u0000\u0000\u0000\u06e3\u06e5\t\u0000\u0000\u0000\u06e4\u06e3\u0001\u0000"+ - "\u0000\u0000\u06e5\u06e8\u0001\u0000\u0000\u0000\u06e6\u06e7\u0001\u0000"+ - "\u0000\u0000\u06e6\u06e4\u0001\u0000\u0000\u0000\u06e7\u06e9\u0001\u0000"+ - "\u0000\u0000\u06e8\u06e6\u0001\u0000\u0000\u0000\u06e9\u06ea\u0005\n\u0000"+ - "\u0000\u06ea\u06eb\u0001\u0000\u0000\u0000\u06eb\u06ec\u0006\u0002\u0001"+ - "\u0000\u06ec\u0006\u0001\u0000\u0000\u0000\u06ed\u06ee\u0007\u0001\u0000"+ - "\u0000\u06ee\b\u0001\u0000\u0000\u0000\u06ef\u06f0\u0007\u0002\u0000\u0000"+ - "\u06f0\n\u0001\u0000\u0000\u0000\u06f1\u06f2\u0007\u0003\u0000\u0000\u06f2"+ - "\f\u0001\u0000\u0000\u0000\u06f3\u06f4\u0007\u0004\u0000\u0000\u06f4\u000e"+ - "\u0001\u0000\u0000\u0000\u06f5\u06f6\u0007\u0005\u0000\u0000\u06f6\u0010"+ - "\u0001\u0000\u0000\u0000\u06f7\u06f8\u0007\u0006\u0000\u0000\u06f8\u0012"+ - "\u0001\u0000\u0000\u0000\u06f9\u06fa\u0007\u0007\u0000\u0000\u06fa\u0014"+ - "\u0001\u0000\u0000\u0000\u06fb\u06fc\u0007\b\u0000\u0000\u06fc\u0016\u0001"+ - "\u0000\u0000\u0000\u06fd\u06fe\u0007\t\u0000\u0000\u06fe\u0018\u0001\u0000"+ - "\u0000\u0000\u06ff\u0700\u0007\n\u0000\u0000\u0700\u001a\u0001\u0000\u0000"+ - "\u0000\u0701\u0702\u0007\u000b\u0000\u0000\u0702\u001c\u0001\u0000\u0000"+ - "\u0000\u0703\u0704\u0007\f\u0000\u0000\u0704\u001e\u0001\u0000\u0000\u0000"+ - "\u0705\u0706\u0007\r\u0000\u0000\u0706 \u0001\u0000\u0000\u0000\u0707"+ - "\u0708\u0007\u000e\u0000\u0000\u0708\"\u0001\u0000\u0000\u0000\u0709\u070a"+ - "\u0007\u000f\u0000\u0000\u070a$\u0001\u0000\u0000\u0000\u070b\u070c\u0007"+ - "\u0010\u0000\u0000\u070c&\u0001\u0000\u0000\u0000\u070d\u070e\u0007\u0011"+ - "\u0000\u0000\u070e(\u0001\u0000\u0000\u0000\u070f\u0710\u0007\u0012\u0000"+ - "\u0000\u0710*\u0001\u0000\u0000\u0000\u0711\u0712\u0007\u0013\u0000\u0000"+ - "\u0712,\u0001\u0000\u0000\u0000\u0713\u0714\u0007\u0014\u0000\u0000\u0714"+ - ".\u0001\u0000\u0000\u0000\u0715\u0716\u0007\u0015\u0000\u0000\u07160\u0001"+ - "\u0000\u0000\u0000\u0717\u0718\u0007\u0016\u0000\u0000\u07182\u0001\u0000"+ - "\u0000\u0000\u0719\u071a\u0007\u0017\u0000\u0000\u071a4\u0001\u0000\u0000"+ - "\u0000\u071b\u071c\u0007\u0018\u0000\u0000\u071c6\u0001\u0000\u0000\u0000"+ - "\u071d\u071e\u0007\u0019\u0000\u0000\u071e8\u0001\u0000\u0000\u0000\u071f"+ - "\u0720\u0007\u001a\u0000\u0000\u0720:\u0001\u0000\u0000\u0000\u0721\u0722"+ - "\u0007\u001b\u0000\u0000\u0722<\u0001\u0000\u0000\u0000\u0723\u0724\u0007"+ - "\u001c\u0000\u0000\u0724>\u0001\u0000\u0000\u0000\u0725\u072d\u0005\""+ - "\u0000\u0000\u0726\u0727\u0005\\\u0000\u0000\u0727\u072c\t\u0000\u0000"+ - "\u0000\u0728\u0729\u0005\"\u0000\u0000\u0729\u072c\u0005\"\u0000\u0000"+ - "\u072a\u072c\b\u001d\u0000\u0000\u072b\u0726\u0001\u0000\u0000\u0000\u072b"+ - "\u0728\u0001\u0000\u0000\u0000\u072b\u072a\u0001\u0000\u0000\u0000\u072c"+ - "\u072f\u0001\u0000\u0000\u0000\u072d\u072b\u0001\u0000\u0000\u0000\u072d"+ - "\u072e\u0001\u0000\u0000\u0000\u072e\u0730\u0001\u0000\u0000\u0000\u072f"+ - "\u072d\u0001\u0000\u0000\u0000\u0730\u0731\u0005\"\u0000\u0000\u0731@"+ - "\u0001\u0000\u0000\u0000\u0732\u073a\u0005\'\u0000\u0000\u0733\u0734\u0005"+ - "\\\u0000\u0000\u0734\u0739\t\u0000\u0000\u0000\u0735\u0736\u0005\'\u0000"+ - "\u0000\u0736\u0739\u0005\'\u0000\u0000\u0737\u0739\b\u001e\u0000\u0000"+ - "\u0738\u0733\u0001\u0000\u0000\u0000\u0738\u0735\u0001\u0000\u0000\u0000"+ - "\u0738\u0737\u0001\u0000\u0000\u0000\u0739\u073c\u0001\u0000\u0000\u0000"+ - "\u073a\u0738\u0001\u0000\u0000\u0000\u073a\u073b\u0001\u0000\u0000\u0000"+ - "\u073b\u073d\u0001\u0000\u0000\u0000\u073c\u073a\u0001\u0000\u0000\u0000"+ - "\u073d\u073e\u0005\'\u0000\u0000\u073eB\u0001\u0000\u0000\u0000\u073f"+ - "\u0747\u0005`\u0000\u0000\u0740\u0741\u0005\\\u0000\u0000\u0741\u0746"+ - "\t\u0000\u0000\u0000\u0742\u0743\u0005`\u0000\u0000\u0743\u0746\u0005"+ - "`\u0000\u0000\u0744\u0746\b\u001f\u0000\u0000\u0745\u0740\u0001\u0000"+ - "\u0000\u0000\u0745\u0742\u0001\u0000\u0000\u0000\u0745\u0744\u0001\u0000"+ - "\u0000\u0000\u0746\u0749\u0001\u0000\u0000\u0000\u0747\u0745\u0001\u0000"+ - "\u0000\u0000\u0747\u0748\u0001\u0000\u0000\u0000\u0748\u074a\u0001\u0000"+ - "\u0000\u0000\u0749\u0747\u0001\u0000\u0000\u0000\u074a\u074b\u0005`\u0000"+ - "\u0000\u074bD\u0001\u0000\u0000\u0000\u074c\u074d\u0003\u0007\u0003\u0000"+ - "\u074dF\u0001\u0000\u0000\u0000\u074e\u074f\u0003\u0007\u0003\u0000\u074f"+ - "\u0750\u0003\t\u0004\u0000\u0750\u0751\u0003#\u0011\u0000\u0751\u0752"+ - "\u0003)\u0014\u0000\u0752\u0753\u0003-\u0016\u0000\u0753H\u0001\u0000"+ - "\u0000\u0000\u0754\u0755\u0003\u0007\u0003\u0000\u0755\u0756\u0003\t\u0004"+ - "\u0000\u0756\u0757\u0003+\u0015\u0000\u0757J\u0001\u0000\u0000\u0000\u0758"+ - "\u0759\u0003\u0007\u0003\u0000\u0759\u075a\u0003\t\u0004\u0000\u075a\u075b"+ - "\u0003+\u0015\u0000\u075b\u075c\u0003#\u0011\u0000\u075c\u075d\u0003\u001d"+ - "\u000e\u0000\u075d\u075e\u0003/\u0017\u0000\u075e\u075f\u0003-\u0016\u0000"+ - "\u075f\u0760\u0003\u000f\u0007\u0000\u0760L\u0001\u0000\u0000\u0000\u0761"+ - "\u0762\u0003\u0007\u0003\u0000\u0762\u0763\u0003\u000b\u0005\u0000\u0763"+ - "\u0764\u0003\u000b\u0005\u0000\u0764\u0765\u0003\u000f\u0007\u0000\u0765"+ - "\u0766\u0003+\u0015\u0000\u0766\u0767\u0003+\u0015\u0000\u0767N\u0001"+ - "\u0000\u0000\u0000\u0768\u0769\u0003\u0007\u0003\u0000\u0769\u076a\u0003"+ - "\u000b\u0005\u0000\u076a\u076b\u0003-\u0016\u0000\u076b\u076c\u0003\u0017"+ - "\u000b\u0000\u076c\u076d\u0003#\u0011\u0000\u076d\u076e\u0003!\u0010\u0000"+ - "\u076eP\u0001\u0000\u0000\u0000\u076f\u0770\u0003\u0007\u0003\u0000\u0770"+ - "\u0771\u0003\r\u0006\u0000\u0771\u0772\u0003\u0007\u0003\u0000\u0772R"+ - "\u0001\u0000\u0000\u0000\u0773\u0774\u0003\u0007\u0003\u0000\u0774\u0775"+ - "\u0003\r\u0006\u0000\u0775\u0776\u0003\r\u0006\u0000\u0776T\u0001\u0000"+ - "\u0000\u0000\u0777\u0778\u0003\u0007\u0003\u0000\u0778\u0779\u0003\r\u0006"+ - "\u0000\u0779\u077a\u0003\u001f\u000f\u0000\u077a\u077b\u0003\u0017\u000b"+ - "\u0000\u077b\u077c\u0003!\u0010\u0000\u077cV\u0001\u0000\u0000\u0000\u077d"+ - "\u077e\u0003\u0007\u0003\u0000\u077e\u077f\u0003\u0011\b\u0000\u077f\u0780"+ - "\u0003-\u0016\u0000\u0780\u0781\u0003\u000f\u0007\u0000\u0781\u0782\u0003"+ - ")\u0014\u0000\u0782X\u0001\u0000\u0000\u0000\u0783\u0784\u0003\u0007\u0003"+ - "\u0000\u0784\u0785\u0003\u0013\t\u0000\u0785\u0786\u0003\u0013\t\u0000"+ - "\u0786\u0787\u0003)\u0014\u0000\u0787\u0788\u0003\u000f\u0007\u0000\u0788"+ - "\u0789\u0003\u0013\t\u0000\u0789\u078a\u0003\u0007\u0003\u0000\u078a\u078b"+ - "\u0003-\u0016\u0000\u078b\u078c\u0003\u000f\u0007\u0000\u078cZ\u0001\u0000"+ - "\u0000\u0000\u078d\u078e\u0003\u0007\u0003\u0000\u078e\u078f\u0003\u001d"+ - "\u000e\u0000\u078f\u0790\u0003\u0017\u000b\u0000\u0790\u0791\u0003\u0007"+ - "\u0003\u0000\u0791\u0792\u0003+\u0015\u0000\u0792\\\u0001\u0000\u0000"+ - "\u0000\u0793\u0794\u0003\u0007\u0003\u0000\u0794\u0795\u0003\u001d\u000e"+ - "\u0000\u0795\u0796\u0003\u001d\u000e\u0000\u0796^\u0001\u0000\u0000\u0000"+ - "\u0797\u0798\u0003\u0007\u0003\u0000\u0798\u0799\u0003\u001d\u000e\u0000"+ - "\u0799\u079a\u0003\u001d\u000e\u0000\u079a\u079b\u0003#\u0011\u0000\u079b"+ - "\u079c\u0003\u000b\u0005\u0000\u079c\u079d\u0003\u0007\u0003\u0000\u079d"+ - "\u079e\u0003-\u0016\u0000\u079e\u079f\u0003\u000f\u0007\u0000\u079f`\u0001"+ - "\u0000\u0000\u0000\u07a0\u07a1\u0003\u0007\u0003\u0000\u07a1\u07a2\u0003"+ - "\u001d\u000e\u0000\u07a2\u07a3\u0003+\u0015\u0000\u07a3\u07a4\u0003#\u0011"+ - "\u0000\u07a4b\u0001\u0000\u0000\u0000\u07a5\u07a6\u0003\u0007\u0003\u0000"+ - "\u07a6\u07a7\u0003\u001d\u000e\u0000\u07a7\u07a8\u0003-\u0016\u0000\u07a8"+ - "\u07a9\u0003\u000f\u0007\u0000\u07a9\u07aa\u0003)\u0014\u0000\u07aad\u0001"+ - "\u0000\u0000\u0000\u07ab\u07ac\u0003\u0007\u0003\u0000\u07ac\u07ad\u0003"+ - "\u001d\u000e\u0000\u07ad\u07ae\u00033\u0019\u0000\u07ae\u07af\u0003\u0007"+ - "\u0003\u0000\u07af\u07b0\u00037\u001b\u0000\u07b0\u07b1\u0003+\u0015\u0000"+ - "\u07b1f\u0001\u0000\u0000\u0000\u07b2\u07b3\u0003\u0007\u0003\u0000\u07b3"+ - "\u07b4\u0003!\u0010\u0000\u07b4\u07b5\u0003\u0007\u0003\u0000\u07b5\u07b6"+ - "\u0003\u001d\u000e\u0000\u07b6\u07b7\u00037\u001b\u0000\u07b7\u07b8\u0003"+ - "+\u0015\u0000\u07b8\u07b9\u0003\u000f\u0007\u0000\u07b9h\u0001\u0000\u0000"+ - "\u0000\u07ba\u07bb\u0003\u0007\u0003\u0000\u07bb\u07bc\u0003!\u0010\u0000"+ - "\u07bc\u07bd\u0003\u0007\u0003\u0000\u07bd\u07be\u0003\u001d\u000e\u0000"+ - "\u07be\u07bf\u00037\u001b\u0000\u07bf\u07c0\u00039\u001c\u0000\u07c0\u07c1"+ - "\u0003\u000f\u0007\u0000\u07c1j\u0001\u0000\u0000\u0000\u07c2\u07c3\u0003"+ - "\u0007\u0003\u0000\u07c3\u07c4\u0003!\u0010\u0000\u07c4\u07c5\u0003\r"+ - "\u0006\u0000\u07c5l\u0001\u0000\u0000\u0000\u07c6\u07c7\u0003\u0007\u0003"+ - "\u0000\u07c7\u07c8\u0003!\u0010\u0000\u07c8\u07c9\u00037\u001b\u0000\u07c9"+ - "n\u0001\u0000\u0000\u0000\u07ca\u07cb\u0003\u0007\u0003\u0000\u07cb\u07cc"+ - "\u0003)\u0014\u0000\u07cc\u07cd\u0003\u000f\u0007\u0000\u07cdp\u0001\u0000"+ - "\u0000\u0000\u07ce\u07cf\u0003\u0007\u0003\u0000\u07cf\u07d0\u0003)\u0014"+ - "\u0000\u07d0\u07d1\u0003)\u0014\u0000\u07d1\u07d2\u0003\u0007\u0003\u0000"+ - "\u07d2\u07d3\u00037\u001b\u0000\u07d3r\u0001\u0000\u0000\u0000\u07d4\u07d5"+ - "\u0003\u0007\u0003\u0000\u07d5\u07d6\u0003+\u0015\u0000\u07d6t\u0001\u0000"+ - "\u0000\u0000\u07d7\u07d8\u0003\u0007\u0003\u0000\u07d8\u07d9\u0003+\u0015"+ - "\u0000\u07d9\u07da\u0003\u000b\u0005\u0000\u07dav\u0001\u0000\u0000\u0000"+ - "\u07db\u07dc\u0003\u0007\u0003\u0000\u07dc\u07dd\u0003+\u0015\u0000\u07dd"+ - "\u07de\u0003\u000f\u0007\u0000\u07de\u07df\u0003!\u0010\u0000\u07df\u07e0"+ - "\u0003+\u0015\u0000\u07e0\u07e1\u0003\u0017\u000b\u0000\u07e1\u07e2\u0003"+ - "-\u0016\u0000\u07e2\u07e3\u0003\u0017\u000b\u0000\u07e3\u07e4\u00031\u0018"+ - "\u0000\u07e4\u07e5\u0003\u000f\u0007\u0000\u07e5x\u0001\u0000\u0000\u0000"+ - "\u07e6\u07e7\u0003\u0007\u0003\u0000\u07e7\u07e8\u0003+\u0015\u0000\u07e8"+ - "\u07e9\u0003+\u0015\u0000\u07e9\u07ea\u0003\u000f\u0007\u0000\u07ea\u07eb"+ - "\u0003)\u0014\u0000\u07eb\u07ec\u0003-\u0016\u0000\u07ec\u07ed\u0003\u0017"+ - "\u000b\u0000\u07ed\u07ee\u0003#\u0011\u0000\u07ee\u07ef\u0003!\u0010\u0000"+ - "\u07efz\u0001\u0000\u0000\u0000\u07f0\u07f1\u0003\u0007\u0003\u0000\u07f1"+ - "\u07f2\u0003+\u0015\u0000\u07f2\u07f3\u0003+\u0015\u0000\u07f3\u07f4\u0003"+ - "\u0017\u000b\u0000\u07f4\u07f5\u0003\u0013\t\u0000\u07f5\u07f6\u0003!"+ - "\u0010\u0000\u07f6\u07f7\u0003\u001f\u000f\u0000\u07f7\u07f8\u0003\u000f"+ - "\u0007\u0000\u07f8\u07f9\u0003!\u0010\u0000\u07f9\u07fa\u0003-\u0016\u0000"+ - "\u07fa|\u0001\u0000\u0000\u0000\u07fb\u07fc\u0003\u0007\u0003\u0000\u07fc"+ - "\u07fd\u0003+\u0015\u0000\u07fd\u07fe\u00037\u001b\u0000\u07fe\u07ff\u0003"+ - "\u001f\u000f\u0000\u07ff\u0800\u0003\u001f\u000f\u0000\u0800\u0801\u0003"+ - "\u000f\u0007\u0000\u0801\u0802\u0003-\u0016\u0000\u0802\u0803\u0003)\u0014"+ - "\u0000\u0803\u0804\u0003\u0017\u000b\u0000\u0804\u0805\u0003\u000b\u0005"+ - "\u0000\u0805~\u0001\u0000\u0000\u0000\u0806\u0807\u0003\u0007\u0003\u0000"+ - "\u0807\u0808\u0003-\u0016\u0000\u0808\u0080\u0001\u0000\u0000\u0000\u0809"+ - "\u080a\u0003\u0007\u0003\u0000\u080a\u080b\u0003-\u0016\u0000\u080b\u080c"+ - "\u0003#\u0011\u0000\u080c\u080d\u0003\u001f\u000f\u0000\u080d\u080e\u0003"+ - "\u0017\u000b\u0000\u080e\u080f\u0003\u000b\u0005\u0000\u080f\u0082\u0001"+ - "\u0000\u0000\u0000\u0810\u0811\u0003\u0007\u0003\u0000\u0811\u0812\u0003"+ - "-\u0016\u0000\u0812\u0813\u0003-\u0016\u0000\u0813\u0814\u0003)\u0014"+ - "\u0000\u0814\u0815\u0003\u0017\u000b\u0000\u0815\u0816\u0003\t\u0004\u0000"+ - "\u0816\u0817\u0003/\u0017\u0000\u0817\u0818\u0003-\u0016\u0000\u0818\u0819"+ - "\u0003\u000f\u0007\u0000\u0819\u0084\u0001\u0000\u0000\u0000\u081a\u081b"+ - "\u0003\u0007\u0003\u0000\u081b\u081c\u0003-\u0016\u0000\u081c\u081d\u0003"+ - "-\u0016\u0000\u081d\u081e\u0003)\u0014\u0000\u081e\u081f\u0003\u0017\u000b"+ - "\u0000\u081f\u0820\u0003\t\u0004\u0000\u0820\u0821\u0003/\u0017\u0000"+ - "\u0821\u0822\u0003-\u0016\u0000\u0822\u0823\u0003\u000f\u0007\u0000\u0823"+ - "\u0824\u0003+\u0015\u0000\u0824\u0086\u0001\u0000\u0000\u0000\u0825\u0826"+ - "\u0003\u0007\u0003\u0000\u0826\u0827\u0003/\u0017\u0000\u0827\u0828\u0003"+ - "-\u0016\u0000\u0828\u0829\u0003\u0015\n\u0000\u0829\u082a\u0003#\u0011"+ - "\u0000\u082a\u082b\u0003)\u0014\u0000\u082b\u082c\u0003\u0017\u000b\u0000"+ - "\u082c\u082d\u00039\u001c\u0000\u082d\u082e\u0003\u0007\u0003\u0000\u082e"+ - "\u082f\u0003-\u0016\u0000\u082f\u0830\u0003\u0017\u000b\u0000\u0830\u0831"+ - "\u0003#\u0011\u0000\u0831\u0832\u0003!\u0010\u0000\u0832\u0088\u0001\u0000"+ - "\u0000\u0000\u0833\u0834\u0003\u0007\u0003\u0000\u0834\u0835\u00031\u0018"+ - "\u0000\u0835\u0836\u0003\u0013\t\u0000\u0836\u008a\u0001\u0000\u0000\u0000"+ - "\u0837\u0838\u0003\t\u0004\u0000\u0838\u0839\u0003\u0007\u0003\u0000\u0839"+ - "\u083a\u0003\u000b\u0005\u0000\u083a\u083b\u0003\u001b\r\u0000\u083b\u083c"+ - "\u00033\u0019\u0000\u083c\u083d\u0003\u0007\u0003\u0000\u083d\u083e\u0003"+ - ")\u0014\u0000\u083e\u083f\u0003\r\u0006\u0000\u083f\u008c\u0001\u0000"+ - "\u0000\u0000\u0840\u0841\u0003\t\u0004\u0000\u0841\u0842\u0003\u000f\u0007"+ - "\u0000\u0842\u0843\u0003\u0011\b\u0000\u0843\u0844\u0003#\u0011\u0000"+ - "\u0844\u0845\u0003)\u0014\u0000\u0845\u0846\u0003\u000f\u0007\u0000\u0846"+ - "\u008e\u0001\u0000\u0000\u0000\u0847\u0848\u0003\t\u0004\u0000\u0848\u0849"+ - "\u0003\u000f\u0007\u0000\u0849\u084a\u0003\u0013\t\u0000\u084a\u084b\u0003"+ - "\u0017\u000b\u0000\u084b\u084c\u0003!\u0010\u0000\u084c\u0090\u0001\u0000"+ - "\u0000\u0000\u084d\u084e\u0003\t\u0004\u0000\u084e\u084f\u0003\u000f\u0007"+ - "\u0000\u084f\u0850\u0003)\u0014\u0000\u0850\u0851\u0003!\u0010\u0000\u0851"+ - "\u0852\u0003#\u0011\u0000\u0852\u0853\u0003/\u0017\u0000\u0853\u0854\u0003"+ - "\u001d\u000e\u0000\u0854\u0855\u0003\u001d\u000e\u0000\u0855\u0856\u0003"+ - "\u0017\u000b\u0000\u0856\u0092\u0001\u0000\u0000\u0000\u0857\u0858\u0003"+ - "\t\u0004\u0000\u0858\u0859\u0003\u000f\u0007\u0000\u0859\u085a\u0003-"+ - "\u0016\u0000\u085a\u085b\u00033\u0019\u0000\u085b\u085c\u0003\u000f\u0007"+ - "\u0000\u085c\u085d\u0003\u000f\u0007\u0000\u085d\u085e\u0003!\u0010\u0000"+ - "\u085e\u0094\u0001\u0000\u0000\u0000\u085f\u0860\u0003\t\u0004\u0000\u0860"+ - "\u0861\u0003\u0017\u000b\u0000\u0861\u0862\u0003\u0013\t\u0000\u0862\u0863"+ - "\u0003\u0017\u000b\u0000\u0863\u0864\u0003!\u0010\u0000\u0864\u0865\u0003"+ - "-\u0016\u0000\u0865\u0096\u0001\u0000\u0000\u0000\u0866\u0867\u0003\t"+ - "\u0004\u0000\u0867\u0868\u0003\u0017\u000b\u0000\u0868\u0869\u0003!\u0010"+ - "\u0000\u0869\u086a\u0003\u0007\u0003\u0000\u086a\u086b\u0003)\u0014\u0000"+ - "\u086b\u086c\u00037\u001b\u0000\u086c\u0098\u0001\u0000\u0000\u0000\u086d"+ - "\u086e\u0003\t\u0004\u0000\u086e\u086f\u0003\u0017\u000b\u0000\u086f\u0870"+ - "\u0003-\u0016\u0000\u0870\u009a\u0001\u0000\u0000\u0000\u0871\u0872\u0003"+ - "\t\u0004\u0000\u0872\u0873\u0003\u0017\u000b\u0000\u0873\u0874\u0003-"+ - "\u0016\u0000\u0874\u0875\u0005_\u0000\u0000\u0875\u0876\u0003\u001d\u000e"+ - "\u0000\u0876\u0877\u0003\u000f\u0007\u0000\u0877\u0878\u0003!\u0010\u0000"+ - "\u0878\u0879\u0003\u0013\t\u0000\u0879\u087a\u0003-\u0016\u0000\u087a"+ - "\u087b\u0003\u0015\n\u0000\u087b\u009c\u0001\u0000\u0000\u0000\u087c\u087d"+ - "\u0003\t\u0004\u0000\u087d\u087e\u0003\u0017\u000b\u0000\u087e\u087f\u0003"+ - "-\u0016\u0000\u087f\u0880\u00031\u0018\u0000\u0880\u0881\u0003\u0007\u0003"+ - "\u0000\u0881\u0882\u0003)\u0014\u0000\u0882\u009e\u0001\u0000\u0000\u0000"+ - "\u0883\u0884\u0003\t\u0004\u0000\u0884\u0885\u0003\u001d\u000e\u0000\u0885"+ - "\u0886\u0003#\u0011\u0000\u0886\u0887\u0003\t\u0004\u0000\u0887\u00a0"+ - "\u0001\u0000\u0000\u0000\u0888\u0889\u0003\t\u0004\u0000\u0889\u088a\u0003"+ - "#\u0011\u0000\u088a\u088b\u0003#\u0011\u0000\u088b\u088c\u0003\u001d\u000e"+ - "\u0000\u088c\u088d\u0003\u000f\u0007\u0000\u088d\u088e\u0003\u0007\u0003"+ - "\u0000\u088e\u088f\u0003!\u0010\u0000\u088f\u00a2\u0001\u0000\u0000\u0000"+ - "\u0890\u0891\u0003\t\u0004\u0000\u0891\u0892\u0003#\u0011\u0000\u0892"+ - "\u0893\u0003-\u0016\u0000\u0893\u0894\u0003\u0015\n\u0000\u0894\u00a4"+ - "\u0001\u0000\u0000\u0000\u0895\u0896\u0003\t\u0004\u0000\u0896\u0897\u0003"+ - ")\u0014\u0000\u0897\u0898\u0003\u000f\u0007\u0000\u0898\u0899\u0003\u0007"+ - "\u0003\u0000\u0899\u089a\u0003\r\u0006\u0000\u089a\u089b\u0003-\u0016"+ - "\u0000\u089b\u089c\u0003\u0015\n\u0000\u089c\u00a6\u0001\u0000\u0000\u0000"+ - "\u089d\u089e\u0003\t\u0004\u0000\u089e\u089f\u0003/\u0017\u0000\u089f"+ - "\u08a0\u0003\u0011\b\u0000\u08a0\u08a1\u0003\u0011\b\u0000\u08a1\u08a2"+ - "\u0003\u000f\u0007\u0000\u08a2\u08a3\u0003)\u0014\u0000\u08a3\u08a4\u0003"+ - "+\u0015\u0000\u08a4\u00a8\u0001\u0000\u0000\u0000\u08a5\u08a6\u0003\t"+ - "\u0004\u0000\u08a6\u08a7\u00037\u001b\u0000\u08a7\u00aa\u0001\u0000\u0000"+ - "\u0000\u08a8\u08a9\u0003\u000b\u0005\u0000\u08a9\u00ac\u0001\u0000\u0000"+ - "\u0000\u08aa\u08ab\u0003\u000b\u0005\u0000\u08ab\u08ac\u0003\u0007\u0003"+ - "\u0000\u08ac\u08ad\u0003\u000b\u0005\u0000\u08ad\u08ae\u0003\u0015\n\u0000"+ - "\u08ae\u08af\u0003\u000f\u0007\u0000\u08af\u00ae\u0001\u0000\u0000\u0000"+ - "\u08b0\u08b1\u0003\u000b\u0005\u0000\u08b1\u08b2\u0003\u0007\u0003\u0000"+ - "\u08b2\u08b3\u0003\u001d\u000e\u0000\u08b3\u08b4\u0003\u001d\u000e\u0000"+ - "\u08b4\u00b0\u0001\u0000\u0000\u0000\u08b5\u08b6\u0003\u000b\u0005\u0000"+ - "\u08b6\u08b7\u0003\u0007\u0003\u0000\u08b7\u08b8\u0003\u001d\u000e\u0000"+ - "\u08b8\u08b9\u0003\u001d\u000e\u0000\u08b9\u08ba\u0003\u000f\u0007\u0000"+ - "\u08ba\u08bb\u0003\r\u0006\u0000\u08bb\u00b2\u0001\u0000\u0000\u0000\u08bc"+ - "\u08bd\u0003\u000b\u0005\u0000\u08bd\u08be\u0003\u0007\u0003\u0000\u08be"+ - "\u08bf\u0003)\u0014\u0000\u08bf\u08c0\u0003\r\u0006\u0000\u08c0\u08c1"+ - "\u0003\u0017\u000b\u0000\u08c1\u08c2\u0003!\u0010\u0000\u08c2\u08c3\u0003"+ - "\u0007\u0003\u0000\u08c3\u08c4\u0003\u001d\u000e\u0000\u08c4\u08c5\u0003"+ - "\u0017\u000b\u0000\u08c5\u08c6\u0003-\u0016\u0000\u08c6\u08c7\u00037\u001b"+ - "\u0000\u08c7\u00b4\u0001\u0000\u0000\u0000\u08c8\u08c9\u0003\u000b\u0005"+ - "\u0000\u08c9\u08ca\u0003\u0007\u0003\u0000\u08ca\u08cb\u0003+\u0015\u0000"+ - "\u08cb\u08cc\u0003\u000b\u0005\u0000\u08cc\u08cd\u0003\u0007\u0003\u0000"+ - "\u08cd\u08ce\u0003\r\u0006\u0000\u08ce\u08cf\u0003\u000f\u0007\u0000\u08cf"+ - "\u00b6\u0001\u0000\u0000\u0000\u08d0\u08d1\u0003\u000b\u0005\u0000\u08d1"+ - "\u08d2\u0003\u0007\u0003\u0000\u08d2\u08d3\u0003+\u0015\u0000\u08d3\u08d4"+ - "\u0003\u000b\u0005\u0000\u08d4\u08d5\u0003\u0007\u0003\u0000\u08d5\u08d6"+ - "\u0003\r\u0006\u0000\u08d6\u08d7\u0003\u000f\u0007\u0000\u08d7\u08d8\u0003"+ - "\r\u0006\u0000\u08d8\u00b8\u0001\u0000\u0000\u0000\u08d9\u08da\u0003\u000b"+ - "\u0005\u0000\u08da\u08db\u0003\u0007\u0003\u0000\u08db\u08dc\u0003+\u0015"+ - "\u0000\u08dc\u08dd\u0003\u000f\u0007\u0000\u08dd\u00ba\u0001\u0000\u0000"+ - "\u0000\u08de\u08df\u0003\u000b\u0005\u0000\u08df\u08e0\u0003\u0007\u0003"+ - "\u0000\u08e0\u08e1\u0003+\u0015\u0000\u08e1\u08e2\u0003-\u0016\u0000\u08e2"+ - "\u00bc\u0001\u0000\u0000\u0000\u08e3\u08e4\u0003\u000b\u0005\u0000\u08e4"+ - "\u08e5\u0003\u0007\u0003\u0000\u08e5\u08e6\u0003-\u0016\u0000\u08e6\u08e7"+ - "\u0003\u0007\u0003\u0000\u08e7\u08e8\u0003\u001d\u000e\u0000\u08e8\u08e9"+ - "\u0003#\u0011\u0000\u08e9\u08ea\u0003\u0013\t\u0000\u08ea\u00be\u0001"+ - "\u0000\u0000\u0000\u08eb\u08ec\u0003\u000b\u0005\u0000\u08ec\u08ed\u0003"+ - "\u0007\u0003\u0000\u08ed\u08ee\u0003-\u0016\u0000\u08ee\u08ef\u0003\u0007"+ - "\u0003\u0000\u08ef\u08f0\u0003\u001d\u000e\u0000\u08f0\u08f1\u0003#\u0011"+ - "\u0000\u08f1\u08f2\u0003\u0013\t\u0000\u08f2\u08f3\u0005_\u0000\u0000"+ - "\u08f3\u08f4\u0003!\u0010\u0000\u08f4\u08f5\u0003\u0007\u0003\u0000\u08f5"+ - "\u08f6\u0003\u001f\u000f\u0000\u08f6\u08f7\u0003\u000f\u0007\u0000\u08f7"+ - "\u00c0\u0001\u0000\u0000\u0000\u08f8\u08f9\u0003\u000b\u0005\u0000\u08f9"+ - "\u08fa\u0003\u000f\u0007\u0000\u08fa\u08fb\u0003\u0017\u000b\u0000\u08fb"+ - "\u08fc\u0003\u001d\u000e\u0000\u08fc\u00c2\u0001\u0000\u0000\u0000\u08fd"+ - "\u08fe\u0003\u000b\u0005\u0000\u08fe\u08ff\u0003\u000f\u0007\u0000\u08ff"+ - "\u0900\u0003\u0017\u000b\u0000\u0900\u0901\u0003\u001d\u000e\u0000\u0901"+ - "\u0902\u0003\u0017\u000b\u0000\u0902\u0903\u0003!\u0010\u0000\u0903\u0904"+ - "\u0003\u0013\t\u0000\u0904\u00c4\u0001\u0000\u0000\u0000\u0905\u0906\u0003"+ - "\u000b\u0005\u0000\u0906\u0907\u0003\u0015\n\u0000\u0907\u0908\u0003\u0007"+ - "\u0003\u0000\u0908\u0909\u0003\u0017\u000b\u0000\u0909\u090a\u0003!\u0010"+ - "\u0000\u090a\u00c6\u0001\u0000\u0000\u0000\u090b\u090c\u0003\u000b\u0005"+ - "\u0000\u090c\u090d\u0003\u0015\n\u0000\u090d\u090e\u0003\u0007\u0003\u0000"+ - "\u090e\u090f\u0003)\u0014\u0000\u090f\u00c8\u0001\u0000\u0000\u0000\u0910"+ - "\u0911\u0003\u000b\u0005\u0000\u0911\u0912\u0003\u0015\n\u0000\u0912\u0913"+ - "\u0003\u0007\u0003\u0000\u0913\u0914\u0003)\u0014\u0000\u0914\u0915\u0005"+ - "_\u0000\u0000\u0915\u0916\u0003\u001d\u000e\u0000\u0916\u0917\u0003\u000f"+ - "\u0007\u0000\u0917\u0918\u0003!\u0010\u0000\u0918\u0919\u0003\u0013\t"+ - "\u0000\u0919\u091a\u0003-\u0016\u0000\u091a\u091b\u0003\u0015\n\u0000"+ - "\u091b\u00ca\u0001\u0000\u0000\u0000\u091c\u091d\u0003\u000b\u0005\u0000"+ - "\u091d\u091e\u0003\u0015\n\u0000\u091e\u091f\u0003\u0007\u0003\u0000\u091f"+ - "\u0920\u0003)\u0014\u0000\u0920\u0921\u0003\u0007\u0003\u0000\u0921\u0922"+ - "\u0003\u000b\u0005\u0000\u0922\u0923\u0003-\u0016\u0000\u0923\u0924\u0003"+ - "\u000f\u0007\u0000\u0924\u0925\u0003)\u0014\u0000\u0925\u00cc\u0001\u0000"+ - "\u0000\u0000\u0926\u0927\u0003\u000b\u0005\u0000\u0927\u0928\u0003\u0015"+ - "\n\u0000\u0928\u0929\u0003\u0007\u0003\u0000\u0929\u092a\u0003)\u0014"+ - "\u0000\u092a\u092b\u0003\u0007\u0003\u0000\u092b\u092c\u0003\u000b\u0005"+ - "\u0000\u092c\u092d\u0003-\u0016\u0000\u092d\u092e\u0003\u000f\u0007\u0000"+ - "\u092e\u092f\u0003)\u0014\u0000\u092f\u0930\u0005_\u0000\u0000\u0930\u0931"+ - "\u0003\u001d\u000e\u0000\u0931\u0932\u0003\u000f\u0007\u0000\u0932\u0933"+ - "\u0003!\u0010\u0000\u0933\u0934\u0003\u0013\t\u0000\u0934\u0935\u0003"+ - "-\u0016\u0000\u0935\u0936\u0003\u0015\n\u0000\u0936\u00ce\u0001\u0000"+ - "\u0000\u0000\u0937\u0938\u0003\u000b\u0005\u0000\u0938\u0939\u0003\u0015"+ - "\n\u0000\u0939\u093a\u0003\u0007\u0003\u0000\u093a\u093b\u0003)\u0014"+ - "\u0000\u093b\u093c\u0003\u0007\u0003\u0000\u093c\u093d\u0003\u000b\u0005"+ - "\u0000\u093d\u093e\u0003-\u0016\u0000\u093e\u093f\u0003\u000f\u0007\u0000"+ - "\u093f\u0940\u0003)\u0014\u0000\u0940\u0941\u0005_\u0000\u0000\u0941\u0942"+ - "\u0003+\u0015\u0000\u0942\u0943\u0003\u000f\u0007\u0000\u0943\u0944\u0003"+ - "-\u0016\u0000\u0944\u0945\u0005_\u0000\u0000\u0945\u0946\u0003\u000b\u0005"+ - "\u0000\u0946\u0947\u0003\u0007\u0003\u0000\u0947\u0948\u0003-\u0016\u0000"+ - "\u0948\u0949\u0003\u0007\u0003\u0000\u0949\u094a\u0003\u001d\u000e\u0000"+ - "\u094a\u094b\u0003#\u0011\u0000\u094b\u094c\u0003\u0013\t\u0000\u094c"+ - "\u00d0\u0001\u0000\u0000\u0000\u094d\u094e\u0003\u000b\u0005\u0000\u094e"+ - "\u094f\u0003\u0015\n\u0000\u094f\u0950\u0003\u0007\u0003\u0000\u0950\u0951"+ - "\u0003)\u0014\u0000\u0951\u0952\u0003\u0007\u0003\u0000\u0952\u0953\u0003"+ - "\u000b\u0005\u0000\u0953\u0954\u0003-\u0016\u0000\u0954\u0955\u0003\u000f"+ - "\u0007\u0000\u0955\u0956\u0003)\u0014\u0000\u0956\u0957\u0005_\u0000\u0000"+ - "\u0957\u0958\u0003+\u0015\u0000\u0958\u0959\u0003\u000f\u0007\u0000\u0959"+ - "\u095a\u0003-\u0016\u0000\u095a\u095b\u0005_\u0000\u0000\u095b\u095c\u0003"+ - "!\u0010\u0000\u095c\u095d\u0003\u0007\u0003\u0000\u095d\u095e\u0003\u001f"+ - "\u000f\u0000\u095e\u095f\u0003\u000f\u0007\u0000\u095f\u00d2\u0001\u0000"+ - "\u0000\u0000\u0960\u0961\u0003\u000b\u0005\u0000\u0961\u0962\u0003\u0015"+ - "\n\u0000\u0962\u0963\u0003\u0007\u0003\u0000\u0963\u0964\u0003)\u0014"+ - "\u0000\u0964\u0965\u0003\u0007\u0003\u0000\u0965\u0966\u0003\u000b\u0005"+ - "\u0000\u0966\u0967\u0003-\u0016\u0000\u0967\u0968\u0003\u000f\u0007\u0000"+ - "\u0968\u0969\u0003)\u0014\u0000\u0969\u096a\u0005_\u0000\u0000\u096a\u096b"+ - "\u0003+\u0015\u0000\u096b\u096c\u0003\u000f\u0007\u0000\u096c\u096d\u0003"+ - "-\u0016\u0000\u096d\u096e\u0005_\u0000\u0000\u096e\u096f\u0003+\u0015"+ - "\u0000\u096f\u0970\u0003\u000b\u0005\u0000\u0970\u0971\u0003\u0015\n\u0000"+ - "\u0971\u0972\u0003\u000f\u0007\u0000\u0972\u0973\u0003\u001f\u000f\u0000"+ - "\u0973\u0974\u0003\u0007\u0003\u0000\u0974\u00d4\u0001\u0000\u0000\u0000"+ - "\u0975\u0976\u0003\u000b\u0005\u0000\u0976\u0977\u0003\u0015\n\u0000\u0977"+ - "\u0978\u0003\u0007\u0003\u0000\u0978\u0979\u0003)\u0014\u0000\u0979\u097a"+ - "\u0003\u0007\u0003\u0000\u097a\u097b\u0003\u000b\u0005\u0000\u097b\u097c"+ - "\u0003-\u0016\u0000\u097c\u097d\u0003\u000f\u0007\u0000\u097d\u097e\u0003"+ - ")\u0014\u0000\u097e\u097f\u0003\u0017\u000b\u0000\u097f\u0980\u0003+\u0015"+ - "\u0000\u0980\u0981\u0003-\u0016\u0000\u0981\u0982\u0003\u0017\u000b\u0000"+ - "\u0982\u0983\u0003\u000b\u0005\u0000\u0983\u0984\u0003+\u0015\u0000\u0984"+ - "\u00d6\u0001\u0000\u0000\u0000\u0985\u0986\u0003\u000b\u0005\u0000\u0986"+ - "\u0987\u0003\u0015\n\u0000\u0987\u0988\u0003\u0007\u0003\u0000\u0988\u0989"+ - "\u0003)\u0014\u0000\u0989\u098a\u0003\u0007\u0003\u0000\u098a\u098b\u0003"+ - "\u000b\u0005\u0000\u098b\u098c\u0003-\u0016\u0000\u098c\u098d\u0003\u000f"+ - "\u0007\u0000\u098d\u098e\u0003)\u0014\u0000\u098e\u098f\u0003+\u0015\u0000"+ - "\u098f\u00d8\u0001\u0000\u0000\u0000\u0990\u0991\u0003\u000b\u0005\u0000"+ - "\u0991\u0992\u0003\u0015\n\u0000\u0992\u0993\u0003\u000f\u0007\u0000\u0993"+ - "\u0994\u0003\u000b\u0005\u0000\u0994\u0995\u0003\u001b\r\u0000\u0995\u00da"+ - "\u0001\u0000\u0000\u0000\u0996\u0997\u0003\u000b\u0005\u0000\u0997\u0998"+ - "\u0003\u0015\n\u0000\u0998\u0999\u0003\u000f\u0007\u0000\u0999\u099a\u0003"+ - "\u000b\u0005\u0000\u099a\u099b\u0003\u001b\r\u0000\u099b\u099c\u0003\u000f"+ - "\u0007\u0000\u099c\u099d\u0003\r\u0006\u0000\u099d\u00dc\u0001\u0000\u0000"+ - "\u0000\u099e\u099f\u0003\u000b\u0005\u0000\u099f\u09a0\u0003\u0015\n\u0000"+ - "\u09a0\u09a1\u0003\u000f\u0007\u0000\u09a1\u09a2\u0003\u000b\u0005\u0000"+ - "\u09a2\u09a3\u0003\u001b\r\u0000\u09a3\u09a4\u0003%\u0012\u0000\u09a4"+ - "\u09a5\u0003#\u0011\u0000\u09a5\u09a6\u0003\u0017\u000b\u0000\u09a6\u09a7"+ - "\u0003!\u0010\u0000\u09a7\u09a8\u0003-\u0016\u0000\u09a8\u00de\u0001\u0000"+ - "\u0000\u0000\u09a9\u09aa\u0003\u000b\u0005\u0000\u09aa\u09ab\u0003\u001d"+ - "\u000e\u0000\u09ab\u09ac\u0003\u0007\u0003\u0000\u09ac\u09ad\u0003+\u0015"+ - "\u0000\u09ad\u09ae\u0003+\u0015\u0000\u09ae\u00e0\u0001\u0000\u0000\u0000"+ - "\u09af\u09b0\u0003\u000b\u0005\u0000\u09b0\u09b1\u0003\u001d\u000e\u0000"+ - "\u09b1\u09b2\u0003\u0007\u0003\u0000\u09b2\u09b3\u0003+\u0015\u0000\u09b3"+ - "\u09b4\u0003+\u0015\u0000\u09b4\u09b5\u0005_\u0000\u0000\u09b5\u09b6\u0003"+ - "#\u0011\u0000\u09b6\u09b7\u0003)\u0014\u0000\u09b7\u09b8\u0003\u0017\u000b"+ - "\u0000\u09b8\u09b9\u0003\u0013\t\u0000\u09b9\u09ba\u0003\u0017\u000b\u0000"+ - "\u09ba\u09bb\u0003!\u0010\u0000\u09bb\u00e2\u0001\u0000\u0000\u0000\u09bc"+ - "\u09bd\u0003\u000b\u0005\u0000\u09bd\u09be\u0003\u001d\u000e\u0000\u09be"+ - "\u09bf\u0003#\u0011\u0000\u09bf\u09c0\u0003\t\u0004\u0000\u09c0\u00e4"+ - "\u0001\u0000\u0000\u0000\u09c1\u09c2\u0003\u000b\u0005\u0000\u09c2\u09c3"+ - "\u0003\u001d\u000e\u0000\u09c3\u09c4\u0003#\u0011\u0000\u09c4\u09c5\u0003"+ - "+\u0015\u0000\u09c5\u09c6\u0003\u000f\u0007\u0000\u09c6\u00e6\u0001\u0000"+ - "\u0000\u0000\u09c7\u09c8\u0003\u000b\u0005\u0000\u09c8\u09c9\u0003\u001d"+ - "\u000e\u0000\u09c9\u09ca\u0003/\u0017\u0000\u09ca\u09cb\u0003+\u0015\u0000"+ - "\u09cb\u09cc\u0003-\u0016\u0000\u09cc\u09cd\u0003\u000f\u0007\u0000\u09cd"+ - "\u09ce\u0003)\u0014\u0000\u09ce\u00e8\u0001\u0000\u0000\u0000\u09cf\u09d0"+ - "\u0003\u000b\u0005\u0000\u09d0\u09d1\u0003#\u0011\u0000\u09d1\u09d2\u0003"+ - "\u0007\u0003\u0000\u09d2\u09d3\u0003\u001d\u000e\u0000\u09d3\u09d4\u0003"+ - "\u000f\u0007\u0000\u09d4\u09d5\u0003+\u0015\u0000\u09d5\u09d6\u0003\u000b"+ - "\u0005\u0000\u09d6\u09d7\u0003\u000f\u0007\u0000\u09d7\u00ea\u0001\u0000"+ - "\u0000\u0000\u09d8\u09d9\u0003\u000b\u0005\u0000\u09d9\u09da\u0003#\u0011"+ - "\u0000\u09da\u09db\u0003\t\u0004\u0000\u09db\u09dc\u0003#\u0011\u0000"+ - "\u09dc\u09dd\u0003\u001d\u000e\u0000\u09dd\u00ec\u0001\u0000\u0000\u0000"+ - "\u09de\u09df\u0003\u000b\u0005\u0000\u09df\u09e0\u0003#\u0011\u0000\u09e0"+ - "\u09e1\u0003\u001d\u000e\u0000\u09e1\u09e2\u0003\u001d\u000e\u0000\u09e2"+ - "\u09e3\u0003\u0007\u0003\u0000\u09e3\u09e4\u0003-\u0016\u0000\u09e4\u09e5"+ - "\u0003\u000f\u0007\u0000\u09e5\u00ee\u0001\u0000\u0000\u0000\u09e6\u09e7"+ - "\u0003\u000b\u0005\u0000\u09e7\u09e8\u0003#\u0011\u0000\u09e8\u09e9\u0003"+ - "\u001d\u000e\u0000\u09e9\u09ea\u0003\u001d\u000e\u0000\u09ea\u09eb\u0003"+ - "\u0007\u0003\u0000\u09eb\u09ec\u0003-\u0016\u0000\u09ec\u09ed\u0003\u0017"+ - "\u000b\u0000\u09ed\u09ee\u0003#\u0011\u0000\u09ee\u09ef\u0003!\u0010\u0000"+ - "\u09ef\u00f0\u0001\u0000\u0000\u0000\u09f0\u09f1\u0003\u000b\u0005\u0000"+ - "\u09f1\u09f2\u0003#\u0011\u0000\u09f2\u09f3\u0003\u001d\u000e\u0000\u09f3"+ - "\u09f4\u0003\u001d\u000e\u0000\u09f4\u09f5\u0003\u0007\u0003\u0000\u09f5"+ - "\u09f6\u0003-\u0016\u0000\u09f6\u09f7\u0003\u0017\u000b\u0000\u09f7\u09f8"+ - "\u0003#\u0011\u0000\u09f8\u09f9\u0003!\u0010\u0000\u09f9\u09fa\u0005_"+ - "\u0000\u0000\u09fa\u09fb\u0003\u000b\u0005\u0000\u09fb\u09fc\u0003\u0007"+ - "\u0003\u0000\u09fc\u09fd\u0003-\u0016\u0000\u09fd\u09fe\u0003\u0007\u0003"+ - "\u0000\u09fe\u09ff\u0003\u001d\u000e\u0000\u09ff\u0a00\u0003#\u0011\u0000"+ - "\u0a00\u0a01\u0003\u0013\t\u0000\u0a01\u00f2\u0001\u0000\u0000\u0000\u0a02"+ - "\u0a03\u0003\u000b\u0005\u0000\u0a03\u0a04\u0003#\u0011\u0000\u0a04\u0a05"+ - "\u0003\u001d\u000e\u0000\u0a05\u0a06\u0003\u001d\u000e\u0000\u0a06\u0a07"+ - "\u0003\u0007\u0003\u0000\u0a07\u0a08\u0003-\u0016\u0000\u0a08\u0a09\u0003"+ - "\u0017\u000b\u0000\u0a09\u0a0a\u0003#\u0011\u0000\u0a0a\u0a0b\u0003!\u0010"+ - "\u0000\u0a0b\u0a0c\u0005_\u0000\u0000\u0a0c\u0a0d\u0003!\u0010\u0000\u0a0d"+ - "\u0a0e\u0003\u0007\u0003\u0000\u0a0e\u0a0f\u0003\u001f\u000f\u0000\u0a0f"+ - "\u0a10\u0003\u000f\u0007\u0000\u0a10\u00f4\u0001\u0000\u0000\u0000\u0a11"+ - "\u0a12\u0003\u000b\u0005\u0000\u0a12\u0a13\u0003#\u0011\u0000\u0a13\u0a14"+ - "\u0003\u001d\u000e\u0000\u0a14\u0a15\u0003\u001d\u000e\u0000\u0a15\u0a16"+ - "\u0003\u0007\u0003\u0000\u0a16\u0a17\u0003-\u0016\u0000\u0a17\u0a18\u0003"+ - "\u0017\u000b\u0000\u0a18\u0a19\u0003#\u0011\u0000\u0a19\u0a1a\u0003!\u0010"+ - "\u0000\u0a1a\u0a1b\u0005_\u0000\u0000\u0a1b\u0a1c\u0003+\u0015\u0000\u0a1c"+ - "\u0a1d\u0003\u000b\u0005\u0000\u0a1d\u0a1e\u0003\u0015\n\u0000\u0a1e\u0a1f"+ - "\u0003\u000f\u0007\u0000\u0a1f\u0a20\u0003\u001f\u000f\u0000\u0a20\u0a21"+ - "\u0003\u0007\u0003\u0000\u0a21\u00f6\u0001\u0000\u0000\u0000\u0a22\u0a23"+ - "\u0003\u000b\u0005\u0000\u0a23\u0a24\u0003#\u0011\u0000\u0a24\u0a25\u0003"+ - "\u001d\u000e\u0000\u0a25\u0a26\u0003\u001d\u000e\u0000\u0a26\u0a27\u0003"+ - "\u000f\u0007\u0000\u0a27\u0a28\u0003\u000b\u0005\u0000\u0a28\u0a29\u0003"+ - "-\u0016\u0000\u0a29\u00f8\u0001\u0000\u0000\u0000\u0a2a\u0a2b\u0003\u000b"+ - "\u0005\u0000\u0a2b\u0a2c\u0003#\u0011\u0000\u0a2c\u0a2d\u0003\u001d\u000e"+ - "\u0000\u0a2d\u0a2e\u0003/\u0017\u0000\u0a2e\u0a2f\u0003\u001f\u000f\u0000"+ - "\u0a2f\u0a30\u0003!\u0010\u0000\u0a30\u00fa\u0001\u0000\u0000\u0000\u0a31"+ - "\u0a32\u0003\u000b\u0005\u0000\u0a32\u0a33\u0003#\u0011\u0000\u0a33\u0a34"+ - "\u0003\u001d\u000e\u0000\u0a34\u0a35\u0003/\u0017\u0000\u0a35\u0a36\u0003"+ - "\u001f\u000f\u0000\u0a36\u0a37\u0003!\u0010\u0000\u0a37\u0a38\u0005_\u0000"+ - "\u0000\u0a38\u0a39\u0003!\u0010\u0000\u0a39\u0a3a\u0003\u0007\u0003\u0000"+ - "\u0a3a\u0a3b\u0003\u001f\u000f\u0000\u0a3b\u0a3c\u0003\u000f\u0007\u0000"+ - "\u0a3c\u00fc\u0001\u0000\u0000\u0000\u0a3d\u0a3e\u0003\u000b\u0005\u0000"+ - "\u0a3e\u0a3f\u0003#\u0011\u0000\u0a3f\u0a40\u0003\u001f\u000f\u0000\u0a40"+ - "\u0a41\u0003\u001f\u000f\u0000\u0a41\u0a42\u0003\u0007\u0003\u0000\u0a42"+ - "\u0a43\u0003!\u0010\u0000\u0a43\u0a44\u0003\r\u0006\u0000\u0a44\u0a45"+ - "\u0005_\u0000\u0000\u0a45\u0a46\u0003\u0011\b\u0000\u0a46\u0a47\u0003"+ - "/\u0017\u0000\u0a47\u0a48\u0003!\u0010\u0000\u0a48\u0a49\u0003\u000b\u0005"+ - "\u0000\u0a49\u0a4a\u0003-\u0016\u0000\u0a4a\u0a4b\u0003\u0017\u000b\u0000"+ - "\u0a4b\u0a4c\u0003#\u0011\u0000\u0a4c\u0a4d\u0003!\u0010\u0000\u0a4d\u00fe"+ - "\u0001\u0000\u0000\u0000\u0a4e\u0a4f\u0003\u000b\u0005\u0000\u0a4f\u0a50"+ - "\u0003#\u0011\u0000\u0a50\u0a51\u0003\u001f\u000f\u0000\u0a51\u0a52\u0003"+ - "\u001f\u000f\u0000\u0a52\u0a53\u0003\u0007\u0003\u0000\u0a53\u0a54\u0003"+ - "!\u0010\u0000\u0a54\u0a55\u0003\r\u0006\u0000\u0a55\u0a56\u0005_\u0000"+ - "\u0000\u0a56\u0a57\u0003\u0011\b\u0000\u0a57\u0a58\u0003/\u0017\u0000"+ - "\u0a58\u0a59\u0003!\u0010\u0000\u0a59\u0a5a\u0003\u000b\u0005\u0000\u0a5a"+ - "\u0a5b\u0003-\u0016\u0000\u0a5b\u0a5c\u0003\u0017\u000b\u0000\u0a5c\u0a5d"+ - "\u0003#\u0011\u0000\u0a5d\u0a5e\u0003!\u0010\u0000\u0a5e\u0a5f\u0005_"+ - "\u0000\u0000\u0a5f\u0a60\u0003\u000b\u0005\u0000\u0a60\u0a61\u0003#\u0011"+ - "\u0000\u0a61\u0a62\u0003\r\u0006\u0000\u0a62\u0a63\u0003\u000f\u0007\u0000"+ - "\u0a63\u0100\u0001\u0000\u0000\u0000\u0a64\u0a65\u0003\u000b\u0005\u0000"+ - "\u0a65\u0a66\u0003#\u0011\u0000\u0a66\u0a67\u0003\u001f\u000f\u0000\u0a67"+ - "\u0a68\u0003\u001f\u000f\u0000\u0a68\u0a69\u0003\u000f\u0007\u0000\u0a69"+ - "\u0a6a\u0003!\u0010\u0000\u0a6a\u0a6b\u0003-\u0016\u0000\u0a6b\u0102\u0001"+ - "\u0000\u0000\u0000\u0a6c\u0a6d\u0003\u000b\u0005\u0000\u0a6d\u0a6e\u0003"+ - "#\u0011\u0000\u0a6e\u0a6f\u0003\u001f\u000f\u0000\u0a6f\u0a70\u0003\u001f"+ - "\u000f\u0000\u0a70\u0a71\u0003\u0017\u000b\u0000\u0a71\u0a72\u0003-\u0016"+ - "\u0000\u0a72\u0104\u0001\u0000\u0000\u0000\u0a73\u0a74\u0003\u000b\u0005"+ - "\u0000\u0a74\u0a75\u0003#\u0011\u0000\u0a75\u0a76\u0003\u001f\u000f\u0000"+ - "\u0a76\u0a77\u0003\u001f\u000f\u0000\u0a77\u0a78\u0003\u0017\u000b\u0000"+ - "\u0a78\u0a79\u0003-\u0016\u0000\u0a79\u0a7a\u0003-\u0016\u0000\u0a7a\u0a7b"+ - "\u0003\u000f\u0007\u0000\u0a7b\u0a7c\u0003\r\u0006\u0000\u0a7c\u0106\u0001"+ - "\u0000\u0000\u0000\u0a7d\u0a7e\u0003\u000b\u0005\u0000\u0a7e\u0a7f\u0003"+ - "#\u0011\u0000\u0a7f\u0a80\u0003\u001f\u000f\u0000\u0a80\u0a81\u0003%\u0012"+ - "\u0000\u0a81\u0a82\u0003\u001d\u000e\u0000\u0a82\u0a83\u0003\u000f\u0007"+ - "\u0000\u0a83\u0a84\u0003-\u0016\u0000\u0a84\u0a85\u0003\u0017\u000b\u0000"+ - "\u0a85\u0a86\u0003#\u0011\u0000\u0a86\u0a87\u0003!\u0010\u0000\u0a87\u0108"+ - "\u0001\u0000\u0000\u0000\u0a88\u0a89\u0003\u000b\u0005\u0000\u0a89\u0a8a"+ - "\u0003#\u0011\u0000\u0a8a\u0a8b\u0003!\u0010\u0000\u0a8b\u0a8c\u0003\r"+ - "\u0006\u0000\u0a8c\u0a8d\u0003\u0017\u000b\u0000\u0a8d\u0a8e\u0003-\u0016"+ - "\u0000\u0a8e\u0a8f\u0003\u0017\u000b\u0000\u0a8f\u0a90\u0003#\u0011\u0000"+ - "\u0a90\u0a91\u0003!\u0010\u0000\u0a91\u010a\u0001\u0000\u0000\u0000\u0a92"+ - "\u0a93\u0003\u000b\u0005\u0000\u0a93\u0a94\u0003#\u0011\u0000\u0a94\u0a95"+ - "\u0003!\u0010\u0000\u0a95\u0a96\u0003\r\u0006\u0000\u0a96\u0a97\u0003"+ - "\u0017\u000b\u0000\u0a97\u0a98\u0003-\u0016\u0000\u0a98\u0a99\u0003\u0017"+ - "\u000b\u0000\u0a99\u0a9a\u0003#\u0011\u0000\u0a9a\u0a9b\u0003!\u0010\u0000"+ - "\u0a9b\u0a9c\u0005_\u0000\u0000\u0a9c\u0a9d\u0003!\u0010\u0000\u0a9d\u0a9e"+ - "\u0003/\u0017\u0000\u0a9e\u0a9f\u0003\u001f\u000f\u0000\u0a9f\u0aa0\u0003"+ - "\t\u0004\u0000\u0aa0\u0aa1\u0003\u000f\u0007\u0000\u0aa1\u0aa2\u0003)"+ - "\u0014\u0000\u0aa2\u010c\u0001\u0000\u0000\u0000\u0aa3\u0aa4\u0003\u000b"+ - "\u0005\u0000\u0aa4\u0aa5\u0003#\u0011\u0000\u0aa5\u0aa6\u0003!\u0010\u0000"+ - "\u0aa6\u0aa7\u0003\u0011\b\u0000\u0aa7\u0aa8\u0003\u0017\u000b\u0000\u0aa8"+ - "\u0aa9\u0003\u0013\t\u0000\u0aa9\u0aaa\u0003/\u0017\u0000\u0aaa\u0aab"+ - "\u0003)\u0014\u0000\u0aab\u0aac\u0003\u0007\u0003\u0000\u0aac\u0aad\u0003"+ - "-\u0016\u0000\u0aad\u0aae\u0003\u0017\u000b\u0000\u0aae\u0aaf\u0003#\u0011"+ - "\u0000\u0aaf\u0ab0\u0003!\u0010\u0000\u0ab0\u010e\u0001\u0000\u0000\u0000"+ - "\u0ab1\u0ab2\u0003\u000b\u0005\u0000\u0ab2\u0ab3\u0003#\u0011\u0000\u0ab3"+ - "\u0ab4\u0003!\u0010\u0000\u0ab4\u0ab5\u0003\u0011\b\u0000\u0ab5\u0ab6"+ - "\u0003\u001d\u000e\u0000\u0ab6\u0ab7\u0003\u0017\u000b\u0000\u0ab7\u0ab8"+ - "\u0003\u000b\u0005\u0000\u0ab8\u0ab9\u0003-\u0016\u0000\u0ab9\u0110\u0001"+ - "\u0000\u0000\u0000\u0aba\u0abb\u0003\u000b\u0005\u0000\u0abb\u0abc\u0003"+ - "#\u0011\u0000\u0abc\u0abd\u0003!\u0010\u0000\u0abd\u0abe\u0003!\u0010"+ - "\u0000\u0abe\u0abf\u0003\u000f\u0007\u0000\u0abf\u0ac0\u0003\u000b\u0005"+ - "\u0000\u0ac0\u0ac1\u0003-\u0016\u0000\u0ac1\u0112\u0001\u0000\u0000\u0000"+ - "\u0ac2\u0ac3\u0003\u000b\u0005\u0000\u0ac3\u0ac4\u0003#\u0011\u0000\u0ac4"+ - "\u0ac5\u0003!\u0010\u0000\u0ac5\u0ac6\u0003!\u0010\u0000\u0ac6\u0ac7\u0003"+ - "\u000f\u0007\u0000\u0ac7\u0ac8\u0003\u000b\u0005\u0000\u0ac8\u0ac9\u0003"+ - "-\u0016\u0000\u0ac9\u0aca\u0003\u0017\u000b\u0000\u0aca\u0acb\u0003#\u0011"+ - "\u0000\u0acb\u0acc\u0003!\u0010\u0000\u0acc\u0114\u0001\u0000\u0000\u0000"+ - "\u0acd\u0ace\u0003\u000b\u0005\u0000\u0ace\u0acf\u0003#\u0011\u0000\u0acf"+ - "\u0ad0\u0003!\u0010\u0000\u0ad0\u0ad1\u0003!\u0010\u0000\u0ad1\u0ad2\u0003"+ - "\u000f\u0007\u0000\u0ad2\u0ad3\u0003\u000b\u0005\u0000\u0ad3\u0ad4\u0003"+ - "-\u0016\u0000\u0ad4\u0ad5\u0003\u0017\u000b\u0000\u0ad5\u0ad6\u0003#\u0011"+ - "\u0000\u0ad6\u0ad7\u0003!\u0010\u0000\u0ad7\u0ad8\u0005_\u0000\u0000\u0ad8"+ - "\u0ad9\u0003!\u0010\u0000\u0ad9\u0ada\u0003\u0007\u0003\u0000\u0ada\u0adb"+ - "\u0003\u001f\u000f\u0000\u0adb\u0adc\u0003\u000f\u0007\u0000\u0adc\u0116"+ - "\u0001\u0000\u0000\u0000\u0add\u0ade\u0003\u000b\u0005\u0000\u0ade\u0adf"+ - "\u0003#\u0011\u0000\u0adf\u0ae0\u0003!\u0010\u0000\u0ae0\u0ae1\u0003+"+ - "\u0015\u0000\u0ae1\u0ae2\u0003-\u0016\u0000\u0ae2\u0ae3\u0003)\u0014\u0000"+ - "\u0ae3\u0ae4\u0003\u0007\u0003\u0000\u0ae4\u0ae5\u0003\u0017\u000b\u0000"+ - "\u0ae5\u0ae6\u0003!\u0010\u0000\u0ae6\u0ae7\u0003-\u0016\u0000\u0ae7\u0118"+ - "\u0001\u0000\u0000\u0000\u0ae8\u0ae9\u0003\u000b\u0005\u0000\u0ae9\u0aea"+ - "\u0003#\u0011\u0000\u0aea\u0aeb\u0003!\u0010\u0000\u0aeb\u0aec\u0003+"+ - "\u0015\u0000\u0aec\u0aed\u0003-\u0016\u0000\u0aed\u0aee\u0003)\u0014\u0000"+ - "\u0aee\u0aef\u0003\u0007\u0003\u0000\u0aef\u0af0\u0003\u0017\u000b\u0000"+ - "\u0af0\u0af1\u0003!\u0010\u0000\u0af1\u0af2\u0003-\u0016\u0000\u0af2\u0af3"+ - "\u0005_\u0000\u0000\u0af3\u0af4\u0003\u000b\u0005\u0000\u0af4\u0af5\u0003"+ - "\u0007\u0003\u0000\u0af5\u0af6\u0003-\u0016\u0000\u0af6\u0af7\u0003\u0007"+ - "\u0003\u0000\u0af7\u0af8\u0003\u001d\u000e\u0000\u0af8\u0af9\u0003#\u0011"+ - "\u0000\u0af9\u0afa\u0003\u0013\t\u0000\u0afa\u011a\u0001\u0000\u0000\u0000"+ - "\u0afb\u0afc\u0003\u000b\u0005\u0000\u0afc\u0afd\u0003#\u0011\u0000\u0afd"+ - "\u0afe\u0003!\u0010\u0000\u0afe\u0aff\u0003+\u0015\u0000\u0aff\u0b00\u0003"+ - "-\u0016\u0000\u0b00\u0b01\u0003)\u0014\u0000\u0b01\u0b02\u0003\u0007\u0003"+ - "\u0000\u0b02\u0b03\u0003\u0017\u000b\u0000\u0b03\u0b04\u0003!\u0010\u0000"+ - "\u0b04\u0b05\u0003-\u0016\u0000\u0b05\u0b06\u0005_\u0000\u0000\u0b06\u0b07"+ - "\u0003!\u0010\u0000\u0b07\u0b08\u0003\u0007\u0003\u0000\u0b08\u0b09\u0003"+ - "\u001f\u000f\u0000\u0b09\u0b0a\u0003\u000f\u0007\u0000\u0b0a\u011c\u0001"+ - "\u0000\u0000\u0000\u0b0b\u0b0c\u0003\u000b\u0005\u0000\u0b0c\u0b0d\u0003"+ - "#\u0011\u0000\u0b0d\u0b0e\u0003!\u0010\u0000\u0b0e\u0b0f\u0003+\u0015"+ - "\u0000\u0b0f\u0b10\u0003-\u0016\u0000\u0b10\u0b11\u0003)\u0014\u0000\u0b11"+ - "\u0b12\u0003\u0007\u0003\u0000\u0b12\u0b13\u0003\u0017\u000b\u0000\u0b13"+ - "\u0b14\u0003!\u0010\u0000\u0b14\u0b15\u0003-\u0016\u0000\u0b15\u0b16\u0005"+ - "_\u0000\u0000\u0b16\u0b17\u0003+\u0015\u0000\u0b17\u0b18\u0003\u000b\u0005"+ - "\u0000\u0b18\u0b19\u0003\u0015\n\u0000\u0b19\u0b1a\u0003\u000f\u0007\u0000"+ - "\u0b1a\u0b1b\u0003\u001f\u000f\u0000\u0b1b\u0b1c\u0003\u0007\u0003\u0000"+ - "\u0b1c\u011e\u0001\u0000\u0000\u0000\u0b1d\u0b1e\u0003\u000b\u0005\u0000"+ - "\u0b1e\u0b1f\u0003#\u0011\u0000\u0b1f\u0b20\u0003!\u0010\u0000\u0b20\u0b21"+ - "\u0003+\u0015\u0000\u0b21\u0b22\u0003-\u0016\u0000\u0b22\u0b23\u0003)"+ - "\u0014\u0000\u0b23\u0b24\u0003\u0007\u0003\u0000\u0b24\u0b25\u0003\u0017"+ - "\u000b\u0000\u0b25\u0b26\u0003!\u0010\u0000\u0b26\u0b27\u0003-\u0016\u0000"+ - "\u0b27\u0b28\u0003+\u0015\u0000\u0b28\u0120\u0001\u0000\u0000\u0000\u0b29"+ - "\u0b2a\u0003\u000b\u0005\u0000\u0b2a\u0b2b\u0003#\u0011\u0000\u0b2b\u0b2c"+ - "\u0003!\u0010\u0000\u0b2c\u0b2d\u0003+\u0015\u0000\u0b2d\u0b2e\u0003-"+ - "\u0016\u0000\u0b2e\u0b2f\u0003)\u0014\u0000\u0b2f\u0b30\u0003/\u0017\u0000"+ - "\u0b30\u0b31\u0003\u000b\u0005\u0000\u0b31\u0b32\u0003-\u0016\u0000\u0b32"+ - "\u0b33\u0003#\u0011\u0000\u0b33\u0b34\u0003)\u0014\u0000\u0b34\u0122\u0001"+ - "\u0000\u0000\u0000\u0b35\u0b36\u0003\u000b\u0005\u0000\u0b36\u0b37\u0003"+ - "#\u0011\u0000\u0b37\u0b38\u0003!\u0010\u0000\u0b38\u0b39\u0003-\u0016"+ - "\u0000\u0b39\u0b3a\u0003\u0007\u0003\u0000\u0b3a\u0b3b\u0003\u0017\u000b"+ - "\u0000\u0b3b\u0b3c\u0003!\u0010\u0000\u0b3c\u0b3d\u0003+\u0015\u0000\u0b3d"+ - "\u0124\u0001\u0000\u0000\u0000\u0b3e\u0b3f\u0003\u000b\u0005\u0000\u0b3f"+ - "\u0b40\u0003#\u0011\u0000\u0b40\u0b41\u0003!\u0010\u0000\u0b41\u0b42\u0003"+ - "-\u0016\u0000\u0b42\u0b43\u0003\u0017\u000b\u0000\u0b43\u0b44\u0003!\u0010"+ - "\u0000\u0b44\u0b45\u0003/\u0017\u0000\u0b45\u0b46\u0003\u000f\u0007\u0000"+ - "\u0b46\u0126\u0001\u0000\u0000\u0000\u0b47\u0b48\u0003\u000b\u0005\u0000"+ - "\u0b48\u0b49\u0003#\u0011\u0000\u0b49\u0b4a\u0003!\u0010\u0000\u0b4a\u0b4b"+ - "\u00031\u0018\u0000\u0b4b\u0b4c\u0003\u000f\u0007\u0000\u0b4c\u0b4d\u0003"+ - ")\u0014\u0000\u0b4d\u0b4e\u0003+\u0015\u0000\u0b4e\u0b4f\u0003\u0017\u000b"+ - "\u0000\u0b4f\u0b50\u0003#\u0011\u0000\u0b50\u0b51\u0003!\u0010\u0000\u0b51"+ - "\u0128\u0001\u0000\u0000\u0000\u0b52\u0b53\u0003\u000b\u0005\u0000\u0b53"+ - "\u0b54\u0003#\u0011\u0000\u0b54\u0b55\u0003!\u0010\u0000\u0b55\u0b56\u0003"+ - "1\u0018\u0000\u0b56\u0b57\u0003\u000f\u0007\u0000\u0b57\u0b58\u0003)\u0014"+ - "\u0000\u0b58\u0b59\u0003-\u0016\u0000\u0b59\u012a\u0001\u0000\u0000\u0000"+ - "\u0b5a\u0b5b\u0003\u000b\u0005\u0000\u0b5b\u0b5c\u0003#\u0011\u0000\u0b5c"+ - "\u0b5d\u0003%\u0012\u0000\u0b5d\u0b5e\u00037\u001b\u0000\u0b5e\u012c\u0001"+ - "\u0000\u0000\u0000\u0b5f\u0b60\u0003\u000b\u0005\u0000\u0b60\u0b61\u0003"+ - "#\u0011\u0000\u0b61\u0b62\u0003)\u0014\u0000\u0b62\u0b63\u0003)\u0014"+ - "\u0000\u0b63\u012e\u0001\u0000\u0000\u0000\u0b64\u0b65\u0003\u000b\u0005"+ - "\u0000\u0b65\u0b66\u0003#\u0011\u0000\u0b66\u0b67\u0003)\u0014\u0000\u0b67"+ - "\u0b68\u0003)\u0014\u0000\u0b68\u0b69\u0003\u000f\u0007\u0000\u0b69\u0b6a"+ - "\u0003+\u0015\u0000\u0b6a\u0b6b\u0003%\u0012\u0000\u0b6b\u0b6c\u0003#"+ - "\u0011\u0000\u0b6c\u0b6d\u0003!\u0010\u0000\u0b6d\u0b6e\u0003\r\u0006"+ - "\u0000\u0b6e\u0b6f\u0003\u0017\u000b\u0000\u0b6f\u0b70\u0003!\u0010\u0000"+ - "\u0b70\u0b71\u0003\u0013\t\u0000\u0b71\u0130\u0001\u0000\u0000\u0000\u0b72"+ - "\u0b73\u0003\u000b\u0005\u0000\u0b73\u0b74\u0003#\u0011\u0000\u0b74\u0b75"+ - "\u0003+\u0015\u0000\u0b75\u0b76\u0003-\u0016\u0000\u0b76\u0b77\u0003+"+ - "\u0015\u0000\u0b77\u0132\u0001\u0000\u0000\u0000\u0b78\u0b79\u0003\u000b"+ - "\u0005\u0000\u0b79\u0b7a\u0003#\u0011\u0000\u0b7a\u0b7b\u0003/\u0017\u0000"+ - "\u0b7b\u0b7c\u0003!\u0010\u0000\u0b7c\u0b7d\u0003-\u0016\u0000\u0b7d\u0134"+ - "\u0001\u0000\u0000\u0000\u0b7e\u0b7f\u0003\u000b\u0005\u0000\u0b7f\u0b80"+ - "\u0003#\u0011\u0000\u0b80\u0b81\u00031\u0018\u0000\u0b81\u0b82\u0003\u0007"+ - "\u0003\u0000\u0b82\u0b83\u0003)\u0014\u0000\u0b83\u0b84\u0005_\u0000\u0000"+ - "\u0b84\u0b85\u0003%\u0012\u0000\u0b85\u0b86\u0003#\u0011\u0000\u0b86\u0b87"+ - "\u0003%\u0012\u0000\u0b87\u0136\u0001\u0000\u0000\u0000\u0b88\u0b89\u0003"+ - "\u000b\u0005\u0000\u0b89\u0b8a\u0003#\u0011\u0000\u0b8a\u0b8b\u00031\u0018"+ - "\u0000\u0b8b\u0b8c\u0003\u0007\u0003\u0000\u0b8c\u0b8d\u0003)\u0014\u0000"+ - "\u0b8d\u0b8e\u0005_\u0000\u0000\u0b8e\u0b8f\u0003+\u0015\u0000\u0b8f\u0b90"+ - "\u0003\u0007\u0003\u0000\u0b90\u0b91\u0003\u001f\u000f\u0000\u0b91\u0b92"+ - "\u0003%\u0012\u0000\u0b92\u0138\u0001\u0000\u0000\u0000\u0b93\u0b94\u0003"+ - "\u000b\u0005\u0000\u0b94\u0b95\u0003)\u0014\u0000\u0b95\u0b96\u0003\u000f"+ - "\u0007\u0000\u0b96\u0b97\u0003\u0007\u0003\u0000\u0b97\u0b98\u0003-\u0016"+ - "\u0000\u0b98\u0b99\u0003\u000f\u0007\u0000\u0b99\u013a\u0001\u0000\u0000"+ - "\u0000\u0b9a\u0b9b\u0003\u000b\u0005\u0000\u0b9b\u0b9c\u0003)\u0014\u0000"+ - "\u0b9c\u0b9d\u0003\u000f\u0007\u0000\u0b9d\u0b9e\u0003\u0007\u0003\u0000"+ - "\u0b9e\u0b9f\u0003-\u0016\u0000\u0b9f\u0ba0\u0003\u000f\u0007\u0000\u0ba0"+ - "\u0ba1\u0003\r\u0006\u0000\u0ba1\u0ba2\u0003\t\u0004\u0000\u0ba2\u013c"+ - "\u0001\u0000\u0000\u0000\u0ba3\u0ba4\u0003\u000b\u0005\u0000\u0ba4\u0ba5"+ - "\u0003)\u0014\u0000\u0ba5\u0ba6\u0003\u000f\u0007\u0000\u0ba6\u0ba7\u0003"+ - "\u0007\u0003\u0000\u0ba7\u0ba8\u0003-\u0016\u0000\u0ba8\u0ba9\u0003\u000f"+ - "\u0007\u0000\u0ba9\u0baa\u0003/\u0017\u0000\u0baa\u0bab\u0003+\u0015\u0000"+ - "\u0bab\u0bac\u0003\u000f\u0007\u0000\u0bac\u0bad\u0003)\u0014\u0000\u0bad"+ - "\u013e\u0001\u0000\u0000\u0000\u0bae\u0baf\u0003\u000b\u0005\u0000\u0baf"+ - "\u0bb0\u0003)\u0014\u0000\u0bb0\u0bb1\u0003#\u0011\u0000\u0bb1\u0bb2\u0003"+ - "+\u0015\u0000\u0bb2\u0bb3\u0003+\u0015\u0000\u0bb3\u0140\u0001\u0000\u0000"+ - "\u0000\u0bb4\u0bb5\u0003\u000b\u0005\u0000\u0bb5\u0bb6\u0003+\u0015\u0000"+ - "\u0bb6\u0bb7\u00031\u0018\u0000\u0bb7\u0142\u0001\u0000\u0000\u0000\u0bb8"+ - "\u0bb9\u0003\u000b\u0005\u0000\u0bb9\u0bba\u0003/\u0017\u0000\u0bba\u0bbb"+ - "\u0003\t\u0004\u0000\u0bbb\u0bbc\u0003\u000f\u0007\u0000\u0bbc\u0144\u0001"+ - "\u0000\u0000\u0000\u0bbd\u0bbe\u0003\u000b\u0005\u0000\u0bbe\u0bbf\u0003"+ - "/\u0017\u0000\u0bbf\u0bc0\u0003\u001f\u000f\u0000\u0bc0\u0bc1\u0003\u000f"+ - "\u0007\u0000\u0bc1\u0bc2\u0005_\u0000\u0000\u0bc2\u0bc3\u0003\r\u0006"+ - "\u0000\u0bc3\u0bc4\u0003\u0017\u000b\u0000\u0bc4\u0bc5\u0003+\u0015\u0000"+ - "\u0bc5\u0bc6\u0003-\u0016\u0000\u0bc6\u0146\u0001\u0000\u0000\u0000\u0bc7"+ - "\u0bc8\u0003\u000b\u0005\u0000\u0bc8\u0bc9\u0003/\u0017\u0000\u0bc9\u0bca"+ - "\u0003)\u0014\u0000\u0bca\u0bcb\u0003)\u0014\u0000\u0bcb\u0bcc\u0003\u000f"+ - "\u0007\u0000\u0bcc\u0bcd\u0003!\u0010\u0000\u0bcd\u0bce\u0003-\u0016\u0000"+ - "\u0bce\u0148\u0001\u0000\u0000\u0000\u0bcf\u0bd0\u0003\u000b\u0005\u0000"+ - "\u0bd0\u0bd1\u0003/\u0017\u0000\u0bd1\u0bd2\u0003)\u0014\u0000\u0bd2\u0bd3"+ - "\u0003)\u0014\u0000\u0bd3\u0bd4\u0003\u000f\u0007\u0000\u0bd4\u0bd5\u0003"+ - "!\u0010\u0000\u0bd5\u0bd6\u0003-\u0016\u0000\u0bd6\u0bd7\u0005_\u0000"+ - "\u0000\u0bd7\u0bd8\u0003\r\u0006\u0000\u0bd8\u0bd9\u0003\u0007\u0003\u0000"+ - "\u0bd9\u0bda\u0003-\u0016\u0000\u0bda\u0bdb\u0003\u000f\u0007\u0000\u0bdb"+ - "\u014a\u0001\u0000\u0000\u0000\u0bdc\u0bdd\u0003\u000b\u0005\u0000\u0bdd"+ - "\u0bde\u0003/\u0017\u0000\u0bde\u0bdf\u0003)\u0014\u0000\u0bdf\u0be0\u0003"+ - ")\u0014\u0000\u0be0\u0be1\u0003\u000f\u0007\u0000\u0be1\u0be2\u0003!\u0010"+ - "\u0000\u0be2\u0be3\u0003-\u0016\u0000\u0be3\u0be4\u0005_\u0000\u0000\u0be4"+ - "\u0be5\u0003\r\u0006\u0000\u0be5\u0be6\u0003\u000f\u0007\u0000\u0be6\u0be7"+ - "\u0003\u0011\b\u0000\u0be7\u0be8\u0003\u0007\u0003\u0000\u0be8\u0be9\u0003"+ - "/\u0017\u0000\u0be9\u0bea\u0003\u001d\u000e\u0000\u0bea\u0beb\u0003-\u0016"+ - "\u0000\u0beb\u0bec\u0005_\u0000\u0000\u0bec\u0bed\u0003-\u0016\u0000\u0bed"+ - "\u0bee\u0003)\u0014\u0000\u0bee\u0bef\u0003\u0007\u0003\u0000\u0bef\u0bf0"+ - "\u0003!\u0010\u0000\u0bf0\u0bf1\u0003+\u0015\u0000\u0bf1\u0bf2\u0003\u0011"+ - "\b\u0000\u0bf2\u0bf3\u0003#\u0011\u0000\u0bf3\u0bf4\u0003)\u0014\u0000"+ - "\u0bf4\u0bf5\u0003\u001f\u000f\u0000\u0bf5\u0bf6\u0005_\u0000\u0000\u0bf6"+ - "\u0bf7\u0003\u0013\t\u0000\u0bf7\u0bf8\u0003)\u0014\u0000\u0bf8\u0bf9"+ - "\u0003#\u0011\u0000\u0bf9\u0bfa\u0003/\u0017\u0000\u0bfa\u0bfb\u0003%"+ - "\u0012\u0000\u0bfb\u014c\u0001\u0000\u0000\u0000\u0bfc\u0bfd\u0003\u000b"+ - "\u0005\u0000\u0bfd\u0bfe\u0003/\u0017\u0000\u0bfe\u0bff\u0003)\u0014\u0000"+ - "\u0bff\u0c00\u0003)\u0014\u0000\u0c00\u0c01\u0003\u000f\u0007\u0000\u0c01"+ - "\u0c02\u0003!\u0010\u0000\u0c02\u0c03\u0003-\u0016\u0000\u0c03\u0c04\u0005"+ - "_\u0000\u0000\u0c04\u0c05\u0003%\u0012\u0000\u0c05\u0c06\u0003\u0007\u0003"+ - "\u0000\u0c06\u0c07\u0003-\u0016\u0000\u0c07\u0c08\u0003\u0015\n\u0000"+ - "\u0c08\u014e\u0001\u0000\u0000\u0000\u0c09\u0c0a\u0003\u000b\u0005\u0000"+ - "\u0c0a\u0c0b\u0003/\u0017\u0000\u0c0b\u0c0c\u0003)\u0014\u0000\u0c0c\u0c0d"+ - "\u0003)\u0014\u0000\u0c0d\u0c0e\u0003\u000f\u0007\u0000\u0c0e\u0c0f\u0003"+ - "!\u0010\u0000\u0c0f\u0c10\u0003-\u0016\u0000\u0c10\u0c11\u0005_\u0000"+ - "\u0000\u0c11\u0c12\u0003)\u0014\u0000\u0c12\u0c13\u0003#\u0011\u0000\u0c13"+ - "\u0c14\u0003\u001d\u000e\u0000\u0c14\u0c15\u0003\u000f\u0007\u0000\u0c15"+ - "\u0150\u0001\u0000\u0000\u0000\u0c16\u0c17\u0003\u000b\u0005\u0000\u0c17"+ - "\u0c18\u0003/\u0017\u0000\u0c18\u0c19\u0003)\u0014\u0000\u0c19\u0c1a\u0003"+ - ")\u0014\u0000\u0c1a\u0c1b\u0003\u000f\u0007\u0000\u0c1b\u0c1c\u0003!\u0010"+ - "\u0000\u0c1c\u0c1d\u0003-\u0016\u0000\u0c1d\u0c1e\u0005_\u0000\u0000\u0c1e"+ - "\u0c1f\u0003-\u0016\u0000\u0c1f\u0c20\u0003\u0017\u000b\u0000\u0c20\u0c21"+ - "\u0003\u001f\u000f\u0000\u0c21\u0c22\u0003\u000f\u0007\u0000\u0c22\u0152"+ - "\u0001\u0000\u0000\u0000\u0c23\u0c24\u0003\u000b\u0005\u0000\u0c24\u0c25"+ - "\u0003/\u0017\u0000\u0c25\u0c26\u0003)\u0014\u0000\u0c26\u0c27\u0003)"+ - "\u0014\u0000\u0c27\u0c28\u0003\u000f\u0007\u0000\u0c28\u0c29\u0003!\u0010"+ - "\u0000\u0c29\u0c2a\u0003-\u0016\u0000\u0c2a\u0c2b\u0005_\u0000\u0000\u0c2b"+ - "\u0c2c\u0003-\u0016\u0000\u0c2c\u0c2d\u0003\u0017\u000b\u0000\u0c2d\u0c2e"+ - "\u0003\u001f\u000f\u0000\u0c2e\u0c2f\u0003\u000f\u0007\u0000\u0c2f\u0c30"+ - "\u0003+\u0015\u0000\u0c30\u0c31\u0003-\u0016\u0000\u0c31\u0c32\u0003\u0007"+ - "\u0003\u0000\u0c32\u0c33\u0003\u001f\u000f\u0000\u0c33\u0c34\u0003%\u0012"+ - "\u0000\u0c34\u0154\u0001\u0000\u0000\u0000\u0c35\u0c36\u0003\u000b\u0005"+ - "\u0000\u0c36\u0c37\u0003/\u0017\u0000\u0c37\u0c38\u0003)\u0014\u0000\u0c38"+ - "\u0c39\u0003)\u0014\u0000\u0c39\u0c3a\u0003\u000f\u0007\u0000\u0c3a\u0c3b"+ - "\u0003!\u0010\u0000\u0c3b\u0c3c\u0003-\u0016\u0000\u0c3c\u0c3d\u0005_"+ - "\u0000\u0000\u0c3d\u0c3e\u0003-\u0016\u0000\u0c3e\u0c3f\u0003)\u0014\u0000"+ - "\u0c3f\u0c40\u0003\u0007\u0003\u0000\u0c40\u0c41\u0003!\u0010\u0000\u0c41"+ - "\u0c42\u0003+\u0015\u0000\u0c42\u0c43\u0003\u0011\b\u0000\u0c43\u0c44"+ - "\u0003#\u0011\u0000\u0c44\u0c45\u0003)\u0014\u0000\u0c45\u0c46\u0003\u001f"+ - "\u000f\u0000\u0c46\u0c47\u0005_\u0000\u0000\u0c47\u0c48\u0003\u0013\t"+ - "\u0000\u0c48\u0c49\u0003)\u0014\u0000\u0c49\u0c4a\u0003#\u0011\u0000\u0c4a"+ - "\u0c4b\u0003/\u0017\u0000\u0c4b\u0c4c\u0003%\u0012\u0000\u0c4c\u0c4d\u0005"+ - "_\u0000\u0000\u0c4d\u0c4e\u0003\u0011\b\u0000\u0c4e\u0c4f\u0003#\u0011"+ - "\u0000\u0c4f\u0c50\u0003)\u0014\u0000\u0c50\u0c51\u0005_\u0000\u0000\u0c51"+ - "\u0c52\u0003-\u0016\u0000\u0c52\u0c53\u00037\u001b\u0000\u0c53\u0c54\u0003"+ - "%\u0012\u0000\u0c54\u0c55\u0003\u000f\u0007\u0000\u0c55\u0156\u0001\u0000"+ - "\u0000\u0000\u0c56\u0c57\u0003\u000b\u0005\u0000\u0c57\u0c58\u0003/\u0017"+ - "\u0000\u0c58\u0c59\u0003)\u0014\u0000\u0c59\u0c5a\u0003)\u0014\u0000\u0c5a"+ - "\u0c5b\u0003\u000f\u0007\u0000\u0c5b\u0c5c\u0003!\u0010\u0000\u0c5c\u0c5d"+ - "\u0003-\u0016\u0000\u0c5d\u0c5e\u0005_\u0000\u0000\u0c5e\u0c5f\u0003/"+ - "\u0017\u0000\u0c5f\u0c60\u0003+\u0015\u0000\u0c60\u0c61\u0003\u000f\u0007"+ - "\u0000\u0c61\u0c62\u0003)\u0014\u0000\u0c62\u0158\u0001\u0000\u0000\u0000"+ - "\u0c63\u0c64\u0003\u000b\u0005\u0000\u0c64\u0c65\u0003/\u0017\u0000\u0c65"+ - "\u0c66\u0003)\u0014\u0000\u0c66\u0c67\u0003+\u0015\u0000\u0c67\u0c68\u0003"+ - "#\u0011\u0000\u0c68\u0c69\u0003)\u0014\u0000\u0c69\u015a\u0001\u0000\u0000"+ - "\u0000\u0c6a\u0c6b\u0003\u000b\u0005\u0000\u0c6b\u0c6c\u0003/\u0017\u0000"+ - "\u0c6c\u0c6d\u0003)\u0014\u0000\u0c6d\u0c6e\u0003+\u0015\u0000\u0c6e\u0c6f"+ - "\u0003#\u0011\u0000\u0c6f\u0c70\u0003)\u0014\u0000\u0c70\u0c71\u0005_"+ - "\u0000\u0000\u0c71\u0c72\u0003!\u0010\u0000\u0c72\u0c73\u0003\u0007\u0003"+ - "\u0000\u0c73\u0c74\u0003\u001f\u000f\u0000\u0c74\u0c75\u0003\u000f\u0007"+ - "\u0000\u0c75\u015c\u0001\u0000\u0000\u0000\u0c76\u0c77\u0003\u000b\u0005"+ - "\u0000\u0c77\u0c78\u00037\u001b\u0000\u0c78\u0c79\u0003\u000b\u0005\u0000"+ - "\u0c79\u0c7a\u0003\u001d\u000e\u0000\u0c7a\u0c7b\u0003\u000f\u0007\u0000"+ - "\u0c7b\u015e\u0001\u0000\u0000\u0000\u0c7c\u0c7d\u0003\r\u0006\u0000\u0c7d"+ - "\u0c7e\u0003\u0007\u0003\u0000\u0c7e\u0c7f\u0003-\u0016\u0000\u0c7f\u0c80"+ - "\u0003\u0007\u0003\u0000\u0c80\u0160\u0001\u0000\u0000\u0000\u0c81\u0c82"+ - "\u0003\r\u0006\u0000\u0c82\u0c83\u0003\u0007\u0003\u0000\u0c83\u0c84\u0003"+ - "-\u0016\u0000\u0c84\u0c85\u0003\u0007\u0003\u0000\u0c85\u0c86\u0003\t"+ - "\u0004\u0000\u0c86\u0c87\u0003\u0007\u0003\u0000\u0c87\u0c88\u0003+\u0015"+ - "\u0000\u0c88\u0c89\u0003\u000f\u0007\u0000\u0c89\u0162\u0001\u0000\u0000"+ - "\u0000\u0c8a\u0c8b\u0003\r\u0006\u0000\u0c8b\u0c8c\u0003\u0007\u0003\u0000"+ - "\u0c8c\u0c8d\u0003-\u0016\u0000\u0c8d\u0c8e\u0003\u000f\u0007\u0000\u0c8e"+ - "\u0164\u0001\u0000\u0000\u0000\u0c8f\u0c90\u0003\r\u0006\u0000\u0c90\u0c91"+ - "\u0003\u0007\u0003\u0000\u0c91\u0c92\u0003-\u0016\u0000\u0c92\u0c93\u0003"+ - "\u000f\u0007\u0000\u0c93\u0c94\u0003-\u0016\u0000\u0c94\u0c95\u0003\u0017"+ - "\u000b\u0000\u0c95\u0c96\u0003\u001f\u000f\u0000\u0c96\u0c97\u0003\u000f"+ - "\u0007\u0000\u0c97\u0c98\u0005_\u0000\u0000\u0c98\u0c99\u0003\u0017\u000b"+ - "\u0000\u0c99\u0c9a\u0003!\u0010\u0000\u0c9a\u0c9b\u0003-\u0016\u0000\u0c9b"+ - "\u0c9c\u0003\u000f\u0007\u0000\u0c9c\u0c9d\u0003)\u0014\u0000\u0c9d\u0c9e"+ - "\u00031\u0018\u0000\u0c9e\u0c9f\u0003\u0007\u0003\u0000\u0c9f\u0ca0\u0003"+ - "\u001d\u000e\u0000\u0ca0\u0ca1\u0005_\u0000\u0000\u0ca1\u0ca2\u0003\u000b"+ - "\u0005\u0000\u0ca2\u0ca3\u0003#\u0011\u0000\u0ca3\u0ca4\u0003\r\u0006"+ - "\u0000\u0ca4\u0ca5\u0003\u000f\u0007\u0000\u0ca5\u0166\u0001\u0000\u0000"+ - "\u0000\u0ca6\u0ca7\u0003\r\u0006\u0000\u0ca7\u0ca8\u0003\u0007\u0003\u0000"+ - "\u0ca8\u0ca9\u0003-\u0016\u0000\u0ca9\u0caa\u0003\u000f\u0007\u0000\u0caa"+ - "\u0cab\u0003-\u0016\u0000\u0cab\u0cac\u0003\u0017\u000b\u0000\u0cac\u0cad"+ - "\u0003\u001f\u000f\u0000\u0cad\u0cae\u0003\u000f\u0007\u0000\u0cae\u0caf"+ - "\u0005_\u0000\u0000\u0caf\u0cb0\u0003\u0017\u000b\u0000\u0cb0\u0cb1\u0003"+ - "!\u0010\u0000\u0cb1\u0cb2\u0003-\u0016\u0000\u0cb2\u0cb3\u0003\u000f\u0007"+ - "\u0000\u0cb3\u0cb4\u0003)\u0014\u0000\u0cb4\u0cb5\u00031\u0018\u0000\u0cb5"+ - "\u0cb6\u0003\u0007\u0003\u0000\u0cb6\u0cb7\u0003\u001d\u000e\u0000\u0cb7"+ - "\u0cb8\u0005_\u0000\u0000\u0cb8\u0cb9\u0003%\u0012\u0000\u0cb9\u0cba\u0003"+ - ")\u0014\u0000\u0cba\u0cbb\u0003\u000f\u0007\u0000\u0cbb\u0cbc\u0003\u000b"+ - "\u0005\u0000\u0cbc\u0cbd\u0003\u0017\u000b\u0000\u0cbd\u0cbe\u0003+\u0015"+ - "\u0000\u0cbe\u0cbf\u0003\u0017\u000b\u0000\u0cbf\u0cc0\u0003#\u0011\u0000"+ - "\u0cc0\u0cc1\u0003!\u0010\u0000\u0cc1\u0168\u0001\u0000\u0000\u0000\u0cc2"+ - "\u0cc3\u0003\r\u0006\u0000\u0cc3\u0cc4\u0003\u0007\u0003\u0000\u0cc4\u0cc5"+ - "\u00037\u001b\u0000\u0cc5\u016a\u0001\u0000\u0000\u0000\u0cc6\u0cc7\u0003"+ - "\r\u0006\u0000\u0cc7\u0cc8\u0003\u000f\u0007\u0000\u0cc8\u0cc9\u0003\u0007"+ - "\u0003\u0000\u0cc9\u0cca\u0003\u001d\u000e\u0000\u0cca\u0ccb\u0003\u001d"+ - "\u000e\u0000\u0ccb\u0ccc\u0003#\u0011\u0000\u0ccc\u0ccd\u0003\u000b\u0005"+ - "\u0000\u0ccd\u0cce\u0003\u0007\u0003\u0000\u0cce\u0ccf\u0003-\u0016\u0000"+ - "\u0ccf\u0cd0\u0003\u000f\u0007\u0000\u0cd0\u016c\u0001\u0000\u0000\u0000"+ - "\u0cd1\u0cd2\u0003\r\u0006\u0000\u0cd2\u0cd3\u0003\u000f\u0007\u0000\u0cd3"+ - "\u0cd4\u0003\u000b\u0005\u0000\u0cd4\u016e\u0001\u0000\u0000\u0000\u0cd5"+ - "\u0cd6\u0003\r\u0006\u0000\u0cd6\u0cd7\u0003\u000f\u0007\u0000\u0cd7\u0cd8"+ - "\u0003\u000b\u0005\u0000\u0cd8\u0cd9\u0003\u0017\u000b\u0000\u0cd9\u0cda"+ - "\u0003\u001f\u000f\u0000\u0cda\u0cdb\u0003\u0007\u0003\u0000\u0cdb\u0cdc"+ - "\u0003\u001d\u000e\u0000\u0cdc\u0170\u0001\u0000\u0000\u0000\u0cdd\u0cde"+ - "\u0003\r\u0006\u0000\u0cde\u0cdf\u0003\u000f\u0007\u0000\u0cdf\u0ce0\u0003"+ - "\u000b\u0005\u0000\u0ce0\u0ce1\u0003\u001d\u000e\u0000\u0ce1\u0ce2\u0003"+ - "\u0007\u0003\u0000\u0ce2\u0ce3\u0003)\u0014\u0000\u0ce3\u0ce4\u0003\u000f"+ - "\u0007\u0000\u0ce4\u0172\u0001\u0000\u0000\u0000\u0ce5\u0ce6\u0003\r\u0006"+ - "\u0000\u0ce6\u0ce7\u0003\u000f\u0007\u0000\u0ce7\u0ce8\u0003\u0011\b\u0000"+ - "\u0ce8\u0ce9\u0003\u0007\u0003\u0000\u0ce9\u0cea\u0003/\u0017\u0000\u0cea"+ - "\u0ceb\u0003\u001d\u000e\u0000\u0ceb\u0cec\u0003-\u0016\u0000\u0cec\u0174"+ - "\u0001\u0000\u0000\u0000\u0ced\u0cee\u0003\r\u0006\u0000\u0cee\u0cef\u0003"+ - "\u000f\u0007\u0000\u0cef\u0cf0\u0003\u0011\b\u0000\u0cf0\u0cf1\u0003\u0007"+ - "\u0003\u0000\u0cf1\u0cf2\u0003/\u0017\u0000\u0cf2\u0cf3\u0003\u001d\u000e"+ - "\u0000\u0cf3\u0cf4\u0003-\u0016\u0000\u0cf4\u0cf5\u0003+\u0015\u0000\u0cf5"+ - "\u0176\u0001\u0000\u0000\u0000\u0cf6\u0cf7\u0003\r\u0006\u0000\u0cf7\u0cf8"+ - "\u0003\u000f\u0007\u0000\u0cf8\u0cf9\u0003\u0011\b\u0000\u0cf9\u0cfa\u0003"+ - "\u000f\u0007\u0000\u0cfa\u0cfb\u0003)\u0014\u0000\u0cfb\u0cfc\u0003\u0007"+ - "\u0003\u0000\u0cfc\u0cfd\u0003\t\u0004\u0000\u0cfd\u0cfe\u0003\u001d\u000e"+ - "\u0000\u0cfe\u0cff\u0003\u000f\u0007\u0000\u0cff\u0178\u0001\u0000\u0000"+ - "\u0000\u0d00\u0d01\u0003\r\u0006\u0000\u0d01\u0d02\u0003\u000f\u0007\u0000"+ - "\u0d02\u0d03\u0003\u0011\b\u0000\u0d03\u0d04\u0003\u000f\u0007\u0000\u0d04"+ - "\u0d05\u0003)\u0014\u0000\u0d05\u0d06\u0003)\u0014\u0000\u0d06\u0d07\u0003"+ - "\u0007\u0003\u0000\u0d07\u0d08\u0003\t\u0004\u0000\u0d08\u0d09\u0003\u001d"+ - "\u000e\u0000\u0d09\u0d0a\u0003\u000f\u0007\u0000\u0d0a\u017a\u0001\u0000"+ - "\u0000\u0000\u0d0b\u0d0c\u0003\r\u0006\u0000\u0d0c\u0d0d\u0003\u000f\u0007"+ - "\u0000\u0d0d\u0d0e\u0003\u0011\b\u0000\u0d0e\u0d0f\u0003\u000f\u0007\u0000"+ - "\u0d0f\u0d10\u0003)\u0014\u0000\u0d10\u0d11\u0003)\u0014\u0000\u0d11\u0d12"+ - "\u0003\u000f\u0007\u0000\u0d12\u0d13\u0003\r\u0006\u0000\u0d13\u017c\u0001"+ - "\u0000\u0000\u0000\u0d14\u0d15\u0003\r\u0006\u0000\u0d15\u0d16\u0003\u000f"+ - "\u0007\u0000\u0d16\u0d17\u0003\u0011\b\u0000\u0d17\u0d18\u0003\u0017\u000b"+ - "\u0000\u0d18\u0d19\u0003!\u0010\u0000\u0d19\u0d1a\u0003\u000f\u0007\u0000"+ - "\u0d1a\u0d1b\u0003\r\u0006\u0000\u0d1b\u017e\u0001\u0000\u0000\u0000\u0d1c"+ - "\u0d1d\u0003\r\u0006\u0000\u0d1d\u0d1e\u0003\u000f\u0007\u0000\u0d1e\u0d1f"+ - "\u0003\u0011\b\u0000\u0d1f\u0d20\u0003\u0017\u000b\u0000\u0d20\u0d21\u0003"+ - "!\u0010\u0000\u0d21\u0d22\u0003\u000f\u0007\u0000\u0d22\u0d23\u0003)\u0014"+ - "\u0000\u0d23\u0180\u0001\u0000\u0000\u0000\u0d24\u0d25\u0003\r\u0006\u0000"+ - "\u0d25\u0d26\u0003\u000f\u0007\u0000\u0d26\u0d27\u0003\u0013\t\u0000\u0d27"+ - "\u0d28\u0003)\u0014\u0000\u0d28\u0d29\u0003\u000f\u0007\u0000\u0d29\u0d2a"+ - "\u0003\u000f\u0007\u0000\u0d2a\u0182\u0001\u0000\u0000\u0000\u0d2b\u0d2c"+ - "\u0003\r\u0006\u0000\u0d2c\u0d2d\u0003\u000f\u0007\u0000\u0d2d\u0d2e\u0003"+ - "\u001d\u000e\u0000\u0d2e\u0d2f\u0003\u000f\u0007\u0000\u0d2f\u0d30\u0003"+ - "-\u0016\u0000\u0d30\u0d31\u0003\u000f\u0007\u0000\u0d31\u0184\u0001\u0000"+ - "\u0000\u0000\u0d32\u0d33\u0003\r\u0006\u0000\u0d33\u0d34\u0003\u000f\u0007"+ - "\u0000\u0d34\u0d35\u0003\u001d\u000e\u0000\u0d35\u0d36\u0003\u0017\u000b"+ - "\u0000\u0d36\u0d37\u0003\u001f\u000f\u0000\u0d37\u0d38\u0003\u0017\u000b"+ - "\u0000\u0d38\u0d39\u0003-\u0016\u0000\u0d39\u0d3a\u0003\u000f\u0007\u0000"+ - "\u0d3a\u0d3b\u0003)\u0014\u0000\u0d3b\u0186\u0001\u0000\u0000\u0000\u0d3c"+ - "\u0d3d\u0003\r\u0006\u0000\u0d3d\u0d3e\u0003\u000f\u0007\u0000\u0d3e\u0d3f"+ - "\u0003\u001d\u000e\u0000\u0d3f\u0d40\u0003\u0017\u000b\u0000\u0d40\u0d41"+ - "\u0003\u001f\u000f\u0000\u0d41\u0d42\u0003\u0017\u000b\u0000\u0d42\u0d43"+ - "\u0003-\u0016\u0000\u0d43\u0d44\u0003\u000f\u0007\u0000\u0d44\u0d45\u0003"+ - ")\u0014\u0000\u0d45\u0d46\u0003+\u0015\u0000\u0d46\u0188\u0001\u0000\u0000"+ - "\u0000\u0d47\u0d48\u0003\r\u0006\u0000\u0d48\u0d49\u0003\u000f\u0007\u0000"+ - "\u0d49\u0d4a\u0003!\u0010\u0000\u0d4a\u0d4b\u0003+\u0015\u0000\u0d4b\u0d4c"+ - "\u0003\u000f\u0007\u0000\u0d4c\u0d4d\u0005_\u0000\u0000\u0d4d\u0d4e\u0003"+ - ")\u0014\u0000\u0d4e\u0d4f\u0003\u0007\u0003\u0000\u0d4f\u0d50\u0003!\u0010"+ - "\u0000\u0d50\u0d51\u0003\u001b\r\u0000\u0d51\u018a\u0001\u0000\u0000\u0000"+ - "\u0d52\u0d53\u0003\r\u0006\u0000\u0d53\u0d54\u0003\u000f\u0007\u0000\u0d54"+ - "\u0d55\u0003%\u0012\u0000\u0d55\u0d56\u0003\u000f\u0007\u0000\u0d56\u0d57"+ - "\u0003!\u0010\u0000\u0d57\u0d58\u0003\r\u0006\u0000\u0d58\u0d59\u0003"+ - "+\u0015\u0000\u0d59\u018c\u0001\u0000\u0000\u0000\u0d5a\u0d5b\u0003\r"+ - "\u0006\u0000\u0d5b\u0d5c\u0003\u000f\u0007\u0000\u0d5c\u0d5d\u0003%\u0012"+ - "\u0000\u0d5d\u0d5e\u0003-\u0016\u0000\u0d5e\u0d5f\u0003\u0015\n\u0000"+ - "\u0d5f\u018e\u0001\u0000\u0000\u0000\u0d60\u0d61\u0003\r\u0006\u0000\u0d61"+ - "\u0d62\u0003\u000f\u0007\u0000\u0d62\u0d63\u0003)\u0014\u0000\u0d63\u0d64"+ - "\u0003\u000f\u0007\u0000\u0d64\u0d65\u0003\u0011\b\u0000\u0d65\u0190\u0001"+ - "\u0000\u0000\u0000\u0d66\u0d67\u0003\r\u0006\u0000\u0d67\u0d68\u0003\u000f"+ - "\u0007\u0000\u0d68\u0d69\u0003)\u0014\u0000\u0d69\u0d6a\u0003\u0017\u000b"+ - "\u0000\u0d6a\u0d6b\u00031\u0018\u0000\u0d6b\u0d6c\u0003\u000f\u0007\u0000"+ - "\u0d6c\u0d6d\u0003\r\u0006\u0000\u0d6d\u0192\u0001\u0000\u0000\u0000\u0d6e"+ - "\u0d6f\u0003\r\u0006\u0000\u0d6f\u0d70\u0003\u000f\u0007\u0000\u0d70\u0d71"+ - "\u0003+\u0015\u0000\u0d71\u0d72\u0003\u000b\u0005\u0000\u0d72\u0194\u0001"+ - "\u0000\u0000\u0000\u0d73\u0d74\u0003\r\u0006\u0000\u0d74\u0d75\u0003\u000f"+ - "\u0007\u0000\u0d75\u0d76\u0003+\u0015\u0000\u0d76\u0d77\u0003\u000b\u0005"+ - "\u0000\u0d77\u0d78\u0003)\u0014\u0000\u0d78\u0d79\u0003\u0017\u000b\u0000"+ - "\u0d79\u0d7a\u0003\t\u0004\u0000\u0d7a\u0d7b\u0003\u000f\u0007\u0000\u0d7b"+ - "\u0196\u0001\u0000\u0000\u0000\u0d7c\u0d7d\u0003\r\u0006\u0000\u0d7d\u0d7e"+ - "\u0003\u000f\u0007\u0000\u0d7e\u0d7f\u0003+\u0015\u0000\u0d7f\u0d80\u0003"+ - "\u000b\u0005\u0000\u0d80\u0d81\u0003)\u0014\u0000\u0d81\u0d82\u0003\u0017"+ - "\u000b\u0000\u0d82\u0d83\u0003%\u0012\u0000\u0d83\u0d84\u0003-\u0016\u0000"+ - "\u0d84\u0d85\u0003#\u0011\u0000\u0d85\u0d86\u0003)\u0014\u0000\u0d86\u0198"+ - "\u0001\u0000\u0000\u0000\u0d87\u0d88\u0003\r\u0006\u0000\u0d88\u0d89\u0003"+ - "\u000f\u0007\u0000\u0d89\u0d8a\u0003+\u0015\u0000\u0d8a\u0d8b\u0003-\u0016"+ - "\u0000\u0d8b\u0d8c\u0003)\u0014\u0000\u0d8c\u0d8d\u0003#\u0011\u0000\u0d8d"+ - "\u0d8e\u00037\u001b\u0000\u0d8e\u019a\u0001\u0000\u0000\u0000\u0d8f\u0d90"+ - "\u0003\r\u0006\u0000\u0d90\u0d91\u0003\u000f\u0007\u0000\u0d91\u0d92\u0003"+ - "+\u0015\u0000\u0d92\u0d93\u0003-\u0016\u0000\u0d93\u0d94\u0003)\u0014"+ - "\u0000\u0d94\u0d95\u0003/\u0017\u0000\u0d95\u0d96\u0003\u000b\u0005\u0000"+ - "\u0d96\u0d97\u0003-\u0016\u0000\u0d97\u0d98\u0003#\u0011\u0000\u0d98\u0d99"+ - "\u0003)\u0014\u0000\u0d99\u019c\u0001\u0000\u0000\u0000\u0d9a\u0d9b\u0003"+ - "\r\u0006\u0000\u0d9b\u0d9c\u0003\u000f\u0007\u0000\u0d9c\u0d9d\u0003-"+ - "\u0016\u0000\u0d9d\u0d9e\u0003\u000f\u0007\u0000\u0d9e\u0d9f\u0003)\u0014"+ - "\u0000\u0d9f\u0da0\u0003\u001f\u000f\u0000\u0da0\u0da1\u0003\u0017\u000b"+ - "\u0000\u0da1\u0da2\u0003!\u0010\u0000\u0da2\u0da3\u0003\u0017\u000b\u0000"+ - "\u0da3\u0da4\u0003+\u0015\u0000\u0da4\u0da5\u0003-\u0016\u0000\u0da5\u0da6"+ - "\u0003\u0017\u000b\u0000\u0da6\u0da7\u0003\u000b\u0005\u0000\u0da7\u019e"+ - "\u0001\u0000\u0000\u0000\u0da8\u0da9\u0003\r\u0006\u0000\u0da9\u0daa\u0003"+ - "\u0017\u000b\u0000\u0daa\u0dab\u0003\u0007\u0003\u0000\u0dab\u0dac\u0003"+ - "\u0013\t\u0000\u0dac\u0dad\u0003!\u0010\u0000\u0dad\u0dae\u0003#\u0011"+ - "\u0000\u0dae\u0daf\u0003+\u0015\u0000\u0daf\u0db0\u0003-\u0016\u0000\u0db0"+ - "\u0db1\u0003\u0017\u000b\u0000\u0db1\u0db2\u0003\u000b\u0005\u0000\u0db2"+ - "\u0db3\u0003+\u0015\u0000\u0db3\u01a0\u0001\u0000\u0000\u0000\u0db4\u0db5"+ - "\u0003\r\u0006\u0000\u0db5\u0db6\u0003\u0017\u000b\u0000\u0db6\u0db7\u0003"+ - "\u000b\u0005\u0000\u0db7\u0db8\u0003-\u0016\u0000\u0db8\u0db9\u0003\u0017"+ - "\u000b\u0000\u0db9\u0dba\u0003#\u0011\u0000\u0dba\u0dbb\u0003!\u0010\u0000"+ - "\u0dbb\u0dbc\u0003\u0007\u0003\u0000\u0dbc\u0dbd\u0003)\u0014\u0000\u0dbd"+ - "\u0dbe\u00037\u001b\u0000\u0dbe\u01a2\u0001\u0000\u0000\u0000\u0dbf\u0dc0"+ - "\u0003\r\u0006\u0000\u0dc0\u0dc1\u0003\u0017\u000b\u0000\u0dc1\u0dc2\u0003"+ - "+\u0015\u0000\u0dc2\u0dc3\u0003\u0007\u0003\u0000\u0dc3\u0dc4\u0003\t"+ - "\u0004\u0000\u0dc4\u0dc5\u0003\u001d\u000e\u0000\u0dc5\u0dc6\u0003\u000f"+ - "\u0007\u0000\u0dc6\u01a4\u0001\u0000\u0000\u0000\u0dc7\u0dc8\u0003\r\u0006"+ - "\u0000\u0dc8\u0dc9\u0003\u0017\u000b\u0000\u0dc9\u0dca\u0003+\u0015\u0000"+ - "\u0dca\u0dcb\u0003\u0007\u0003\u0000\u0dcb\u0dcc\u0003\t\u0004\u0000\u0dcc"+ - "\u0dcd\u0003\u001d\u000e\u0000\u0dcd\u0dce\u0003\u000f\u0007\u0000\u0dce"+ - "\u0dcf\u0005_\u0000\u0000\u0dcf\u0dd0\u0003%\u0012\u0000\u0dd0\u0dd1\u0003"+ - "\u0007\u0003\u0000\u0dd1\u0dd2\u0003\u0013\t\u0000\u0dd2\u0dd3\u0003\u000f"+ - "\u0007\u0000\u0dd3\u0dd4\u0005_\u0000\u0000\u0dd4\u0dd5\u0003+\u0015\u0000"+ - "\u0dd5\u0dd6\u0003\u001b\r\u0000\u0dd6\u0dd7\u0003\u0017\u000b\u0000\u0dd7"+ - "\u0dd8\u0003%\u0012\u0000\u0dd8\u0dd9\u0003%\u0012\u0000\u0dd9\u0dda\u0003"+ - "\u0017\u000b\u0000\u0dda\u0ddb\u0003!\u0010\u0000\u0ddb\u0ddc\u0003\u0013"+ - "\t\u0000\u0ddc\u01a6\u0001\u0000\u0000\u0000\u0ddd\u0dde\u0003\r\u0006"+ - "\u0000\u0dde\u0ddf\u0003\u0017\u000b\u0000\u0ddf\u0de0\u0003+\u0015\u0000"+ - "\u0de0\u0de1\u0003\u000b\u0005\u0000\u0de1\u0de2\u0003\u0007\u0003\u0000"+ - "\u0de2\u0de3\u0003)\u0014\u0000\u0de3\u0de4\u0003\r\u0006\u0000\u0de4"+ - "\u01a8\u0001\u0000\u0000\u0000\u0de5\u0de6\u0003\r\u0006\u0000\u0de6\u0de7"+ - "\u0003\u0017\u000b\u0000\u0de7\u0de8\u0003+\u0015\u0000\u0de8\u0de9\u0003"+ - "\u000b\u0005\u0000\u0de9\u0dea\u0003#\u0011\u0000\u0dea\u0deb\u0003!\u0010"+ - "\u0000\u0deb\u0dec\u0003!\u0010\u0000\u0dec\u0ded\u0003\u000f\u0007\u0000"+ - "\u0ded\u0dee\u0003\u000b\u0005\u0000\u0dee\u0def\u0003-\u0016\u0000\u0def"+ - "\u01aa\u0001\u0000\u0000\u0000\u0df0\u0df1\u0003\r\u0006\u0000\u0df1\u0df2"+ - "\u0003\u0017\u000b\u0000\u0df2\u0df3\u0003+\u0015\u0000\u0df3\u0df4\u0003"+ - "%\u0012\u0000\u0df4\u0df5\u0003\u0007\u0003\u0000\u0df5\u0df6\u0003-\u0016"+ - "\u0000\u0df6\u0df7\u0003\u000b\u0005\u0000\u0df7\u0df8\u0003\u0015\n\u0000"+ - "\u0df8\u01ac\u0001\u0000\u0000\u0000\u0df9\u0dfa\u0003\r\u0006\u0000\u0dfa"+ - "\u0dfb\u0003\u0017\u000b\u0000\u0dfb\u0dfc\u0003+\u0015\u0000\u0dfc\u0dfd"+ - "\u0003-\u0016\u0000\u0dfd\u0dfe\u0003\u0017\u000b\u0000\u0dfe\u0dff\u0003"+ - "!\u0010\u0000\u0dff\u0e00\u0003\u000b\u0005\u0000\u0e00\u0e01\u0003-\u0016"+ - "\u0000\u0e01\u01ae\u0001\u0000\u0000\u0000\u0e02\u0e03\u0003\r\u0006\u0000"+ - "\u0e03\u0e04\u0003#\u0011\u0000\u0e04\u01b0\u0001\u0000\u0000\u0000\u0e05"+ - "\u0e06\u0003\r\u0006\u0000\u0e06\u0e07\u0003#\u0011\u0000\u0e07\u0e08"+ - "\u0003\u001f\u000f\u0000\u0e08\u0e09\u0003\u0007\u0003\u0000\u0e09\u0e0a"+ - "\u0003\u0017\u000b\u0000\u0e0a\u0e0b\u0003!\u0010\u0000\u0e0b\u01b2\u0001"+ - "\u0000\u0000\u0000\u0e0c\u0e0d\u0003\r\u0006\u0000\u0e0d\u0e0e\u0003#"+ - "\u0011\u0000\u0e0e\u0e0f\u0003/\u0017\u0000\u0e0f\u0e10\u0003\t\u0004"+ - "\u0000\u0e10\u0e11\u0003\u001d\u000e\u0000\u0e11\u0e12\u0003\u000f\u0007"+ - "\u0000\u0e12\u01b4\u0001\u0000\u0000\u0000\u0e13\u0e14\u0003\r\u0006\u0000"+ - "\u0e14\u0e15\u0003)\u0014\u0000\u0e15\u0e16\u0003#\u0011\u0000\u0e16\u0e17"+ - "\u0003%\u0012\u0000\u0e17\u01b6\u0001\u0000\u0000\u0000\u0e18\u0e19\u0003"+ - "\r\u0006\u0000\u0e19\u0e1a\u00037\u001b\u0000\u0e1a\u0e1b\u0003!\u0010"+ - "\u0000\u0e1b\u0e1c\u0003\u0007\u0003\u0000\u0e1c\u0e1d\u0003\u001f\u000f"+ - "\u0000\u0e1d\u0e1e\u0003\u0017\u000b\u0000\u0e1e\u0e1f\u0003\u000b\u0005"+ - "\u0000\u0e1f\u01b8\u0001\u0000\u0000\u0000\u0e20\u0e21\u0003\r\u0006\u0000"+ - "\u0e21\u0e22\u00037\u001b\u0000\u0e22\u0e23\u0003!\u0010\u0000\u0e23\u0e24"+ - "\u0003\u0007\u0003\u0000\u0e24\u0e25\u0003\u001f\u000f\u0000\u0e25\u0e26"+ - "\u0003\u0017\u000b\u0000\u0e26\u0e27\u0003\u000b\u0005\u0000\u0e27\u0e28"+ - "\u0005_\u0000\u0000\u0e28\u0e29\u0003\u0011\b\u0000\u0e29\u0e2a\u0003"+ - "/\u0017\u0000\u0e2a\u0e2b\u0003!\u0010\u0000\u0e2b\u0e2c\u0003\u000b\u0005"+ - "\u0000\u0e2c\u0e2d\u0003-\u0016\u0000\u0e2d\u0e2e\u0003\u0017\u000b\u0000"+ - "\u0e2e\u0e2f\u0003#\u0011\u0000\u0e2f\u0e30\u0003!\u0010\u0000\u0e30\u01ba"+ - "\u0001\u0000\u0000\u0000\u0e31\u0e32\u0003\r\u0006\u0000\u0e32\u0e33\u0003"+ - "7\u001b\u0000\u0e33\u0e34\u0003!\u0010\u0000\u0e34\u0e35\u0003\u0007\u0003"+ - "\u0000\u0e35\u0e36\u0003\u001f\u000f\u0000\u0e36\u0e37\u0003\u0017\u000b"+ - "\u0000\u0e37\u0e38\u0003\u000b\u0005\u0000\u0e38\u0e39\u0005_\u0000\u0000"+ - "\u0e39\u0e3a\u0003\u0011\b\u0000\u0e3a\u0e3b\u0003/\u0017\u0000\u0e3b"+ - "\u0e3c\u0003!\u0010\u0000\u0e3c\u0e3d\u0003\u000b\u0005\u0000\u0e3d\u0e3e"+ - "\u0003-\u0016\u0000\u0e3e\u0e3f\u0003\u0017\u000b\u0000\u0e3f\u0e40\u0003"+ - "#\u0011\u0000\u0e40\u0e41\u0003!\u0010\u0000\u0e41\u0e42\u0005_\u0000"+ - "\u0000\u0e42\u0e43\u0003\u000b\u0005\u0000\u0e43\u0e44\u0003#\u0011\u0000"+ - "\u0e44\u0e45\u0003\r\u0006\u0000\u0e45\u0e46\u0003\u000f\u0007\u0000\u0e46"+ - "\u01bc\u0001\u0000\u0000\u0000\u0e47\u0e48\u0003\u000f\u0007\u0000\u0e48"+ - "\u0e49\u0003\u0007\u0003\u0000\u0e49\u0e4a\u0003\u000b\u0005\u0000\u0e4a"+ - "\u0e4b\u0003\u0015\n\u0000\u0e4b\u01be\u0001\u0000\u0000\u0000\u0e4c\u0e4d"+ - "\u0003\u000f\u0007\u0000\u0e4d\u0e4e\u0003\u001d\u000e\u0000\u0e4e\u0e4f"+ - "\u0003\u000f\u0007\u0000\u0e4f\u0e50\u0003\u001f\u000f\u0000\u0e50\u0e51"+ - "\u0003\u000f\u0007\u0000\u0e51\u0e52\u0003!\u0010\u0000\u0e52\u0e53\u0003"+ - "-\u0016\u0000\u0e53\u01c0\u0001\u0000\u0000\u0000\u0e54\u0e55\u0003\u000f"+ - "\u0007\u0000\u0e55\u0e56\u0003\u001d\u000e\u0000\u0e56\u0e57\u0003+\u0015"+ - "\u0000\u0e57\u0e58\u0003\u000f\u0007\u0000\u0e58\u01c2\u0001\u0000\u0000"+ - "\u0000\u0e59\u0e5a\u0003\u000f\u0007\u0000\u0e5a\u0e5b\u0003!\u0010\u0000"+ - "\u0e5b\u0e5c\u0003\u0007\u0003\u0000\u0e5c\u0e5d\u0003\t\u0004\u0000\u0e5d"+ - "\u0e5e\u0003\u001d\u000e\u0000\u0e5e\u0e5f\u0003\u000f\u0007\u0000\u0e5f"+ - "\u01c4\u0001\u0000\u0000\u0000\u0e60\u0e61\u0003\u000f\u0007\u0000\u0e61"+ - "\u0e62\u0003!\u0010\u0000\u0e62\u0e63\u0003\u000b\u0005\u0000\u0e63\u0e64"+ - "\u0003#\u0011\u0000\u0e64\u0e65\u0003\r\u0006\u0000\u0e65\u0e66\u0003"+ - "\u0017\u000b\u0000\u0e66\u0e67\u0003!\u0010\u0000\u0e67\u0e68\u0003\u0013"+ - "\t\u0000\u0e68\u01c6\u0001\u0000\u0000\u0000\u0e69\u0e6a\u0003\u000f\u0007"+ - "\u0000\u0e6a\u0e6b\u0003!\u0010\u0000\u0e6b\u0e6c\u0003\u000b\u0005\u0000"+ - "\u0e6c\u0e6d\u0003)\u0014\u0000\u0e6d\u0e6e\u00037\u001b\u0000\u0e6e\u0e6f"+ - "\u0003%\u0012\u0000\u0e6f\u0e70\u0003-\u0016\u0000\u0e70\u0e71\u0003\u000f"+ - "\u0007\u0000\u0e71\u0e72\u0003\r\u0006\u0000\u0e72\u01c8\u0001\u0000\u0000"+ - "\u0000\u0e73\u0e74\u0003\u000f\u0007\u0000\u0e74\u0e75\u0003!\u0010\u0000"+ - "\u0e75\u0e76\u0003\r\u0006\u0000\u0e76\u01ca\u0001\u0000\u0000\u0000\u0e77"+ - "\u0e78\u0003\u000f\u0007\u0000\u0e78\u0e79\u0003!\u0010\u0000\u0e79\u0e7a"+ - "\u0003\r\u0006\u0000\u0e7a\u0e7b\u0005-\u0000\u0000\u0e7b\u0e7c\u0003"+ - "\u000f\u0007\u0000\u0e7c\u0e7d\u00035\u001a\u0000\u0e7d\u0e7e\u0003\u000f"+ - "\u0007\u0000\u0e7e\u0e7f\u0003\u000b\u0005\u0000\u0e7f\u01cc\u0001\u0000"+ - "\u0000\u0000\u0e80\u0e81\u0003\u000f\u0007\u0000\u0e81\u0e82\u0003\'\u0013"+ - "\u0000\u0e82\u0e83\u0003/\u0017\u0000\u0e83\u0e84\u0003\u0007\u0003\u0000"+ - "\u0e84\u0e85\u0003\u001d\u000e\u0000\u0e85\u0e86\u0003+\u0015\u0000\u0e86"+ - "\u01ce\u0001\u0000\u0000\u0000\u0e87\u0e88\u0003\u000f\u0007\u0000\u0e88"+ - "\u0e89\u0003+\u0015\u0000\u0e89\u0e8a\u0003\u000b\u0005\u0000\u0e8a\u0e8b"+ - "\u0003\u0007\u0003\u0000\u0e8b\u0e8c\u0003%\u0012\u0000\u0e8c\u0e8d\u0003"+ - "\u000f\u0007\u0000\u0e8d\u01d0\u0001\u0000\u0000\u0000\u0e8e\u0e8f\u0003"+ - "\u000f\u0007\u0000\u0e8f\u0e90\u00031\u0018\u0000\u0e90\u0e91\u0003\u000f"+ - "\u0007\u0000\u0e91\u0e92\u0003)\u0014\u0000\u0e92\u0e93\u00037\u001b\u0000"+ - "\u0e93\u01d2\u0001\u0000\u0000\u0000\u0e94\u0e95\u0003\u000f\u0007\u0000"+ - "\u0e95\u0e96\u00035\u001a\u0000\u0e96\u0e97\u0003\u000b\u0005\u0000\u0e97"+ - "\u0e98\u0003\u000f\u0007\u0000\u0e98\u0e99\u0003%\u0012\u0000\u0e99\u0e9a"+ - "\u0003-\u0016\u0000\u0e9a\u01d4\u0001\u0000\u0000\u0000\u0e9b\u0e9c\u0003"+ - "\u000f\u0007\u0000\u0e9c\u0e9d\u00035\u001a\u0000\u0e9d\u0e9e\u0003\u000b"+ - "\u0005\u0000\u0e9e\u0e9f\u0003\u000f\u0007\u0000\u0e9f\u0ea0\u0003%\u0012"+ - "\u0000\u0ea0\u0ea1\u0003-\u0016\u0000\u0ea1\u0ea2\u0003\u0017\u000b\u0000"+ - "\u0ea2\u0ea3\u0003#\u0011\u0000\u0ea3\u0ea4\u0003!\u0010\u0000\u0ea4\u01d6"+ - "\u0001\u0000\u0000\u0000\u0ea5\u0ea6\u0003\u000f\u0007\u0000\u0ea6\u0ea7"+ - "\u00035\u001a\u0000\u0ea7\u0ea8\u0003\u000b\u0005\u0000\u0ea8\u0ea9\u0003"+ - "\u001d\u000e\u0000\u0ea9\u0eaa\u0003/\u0017\u0000\u0eaa\u0eab\u0003\r"+ - "\u0006\u0000\u0eab\u0eac\u0003\u000f\u0007\u0000\u0eac\u01d8\u0001\u0000"+ - "\u0000\u0000\u0ead\u0eae\u0003\u000f\u0007\u0000\u0eae\u0eaf\u00035\u001a"+ - "\u0000\u0eaf\u0eb0\u0003\u000b\u0005\u0000\u0eb0\u0eb1\u0003\u001d\u000e"+ - "\u0000\u0eb1\u0eb2\u0003/\u0017\u0000\u0eb2\u0eb3\u0003\r\u0006\u0000"+ - "\u0eb3\u0eb4\u0003\u0017\u000b\u0000\u0eb4\u0eb5\u0003!\u0010\u0000\u0eb5"+ - "\u0eb6\u0003\u0013\t\u0000\u0eb6\u01da\u0001\u0000\u0000\u0000\u0eb7\u0eb8"+ - "\u0003\u000f\u0007\u0000\u0eb8\u0eb9\u00035\u001a\u0000\u0eb9\u0eba\u0003"+ - "\u000b\u0005\u0000\u0eba\u0ebb\u0003\u001d\u000e\u0000\u0ebb\u0ebc\u0003"+ - "/\u0017\u0000\u0ebc\u0ebd\u0003+\u0015\u0000\u0ebd\u0ebe\u0003\u0017\u000b"+ - "\u0000\u0ebe\u0ebf\u00031\u0018\u0000\u0ebf\u0ec0\u0003\u000f\u0007\u0000"+ - "\u0ec0\u01dc\u0001\u0000\u0000\u0000\u0ec1\u0ec2\u0003\u000f\u0007\u0000"+ - "\u0ec2\u0ec3\u00035\u001a\u0000\u0ec3\u0ec4\u0003\u000f\u0007\u0000\u0ec4"+ - "\u0ec5\u0003\u000b\u0005\u0000\u0ec5\u01de\u0001\u0000\u0000\u0000\u0ec6"+ - "\u0ec7\u0003\u000f\u0007\u0000\u0ec7\u0ec8\u00035\u001a\u0000\u0ec8\u0ec9"+ - "\u0003\u000f\u0007\u0000\u0ec9\u0eca\u0003\u000b\u0005\u0000\u0eca\u0ecb"+ - "\u0003/\u0017\u0000\u0ecb\u0ecc\u0003-\u0016\u0000\u0ecc\u0ecd\u0003\u000f"+ - "\u0007\u0000\u0ecd\u01e0\u0001\u0000\u0000\u0000\u0ece\u0ecf\u0003\u000f"+ - "\u0007\u0000\u0ecf\u0ed0\u00035\u001a\u0000\u0ed0\u0ed1\u0003\u0017\u000b"+ - "\u0000\u0ed1\u0ed2\u0003+\u0015\u0000\u0ed2\u0ed3\u0003-\u0016\u0000\u0ed3"+ - "\u0ed4\u0003\u0017\u000b\u0000\u0ed4\u0ed5\u0003!\u0010\u0000\u0ed5\u0ed6"+ - "\u0003\u0013\t\u0000\u0ed6\u01e2\u0001\u0000\u0000\u0000\u0ed7\u0ed8\u0003"+ - "\u000f\u0007\u0000\u0ed8\u0ed9\u00035\u001a\u0000\u0ed9\u0eda\u0003\u0017"+ - "\u000b\u0000\u0eda\u0edb\u0003+\u0015\u0000\u0edb\u0edc\u0003-\u0016\u0000"+ - "\u0edc\u0edd\u0003+\u0015\u0000\u0edd\u01e4\u0001\u0000\u0000\u0000\u0ede"+ - "\u0edf\u0003\u000f\u0007\u0000\u0edf\u0ee0\u00035\u001a\u0000\u0ee0\u0ee1"+ - "\u0003%\u0012\u0000\u0ee1\u01e6\u0001\u0000\u0000\u0000\u0ee2\u0ee3\u0003"+ - "\u000f\u0007\u0000\u0ee3\u0ee4\u00035\u001a\u0000\u0ee4\u0ee5\u0003%\u0012"+ - "\u0000\u0ee5\u0ee6\u0003\u001d\u000e\u0000\u0ee6\u0ee7\u0003\u0007\u0003"+ - "\u0000\u0ee7\u0ee8\u0003\u0017\u000b\u0000\u0ee8\u0ee9\u0003!\u0010\u0000"+ - "\u0ee9\u01e8\u0001\u0000\u0000\u0000\u0eea\u0eeb\u0003\u000f\u0007\u0000"+ - "\u0eeb\u0eec\u00035\u001a\u0000\u0eec\u0eed\u0003-\u0016\u0000\u0eed\u0eee"+ - "\u0003\u000f\u0007\u0000\u0eee\u0eef\u0003!\u0010\u0000\u0eef\u0ef0\u0003"+ - "\r\u0006\u0000\u0ef0\u0ef1\u0003\u000f\u0007\u0000\u0ef1\u0ef2\u0003\r"+ - "\u0006\u0000\u0ef2\u01ea\u0001\u0000\u0000\u0000\u0ef3\u0ef4\u0003\u000f"+ - "\u0007\u0000\u0ef4\u0ef5\u00035\u001a\u0000\u0ef5\u0ef6\u0003-\u0016\u0000"+ - "\u0ef6\u0ef7\u0003\u000f\u0007\u0000\u0ef7\u0ef8\u0003!\u0010\u0000\u0ef8"+ - "\u0ef9\u0003+\u0015\u0000\u0ef9\u0efa\u0003\u0017\u000b\u0000\u0efa\u0efb"+ - "\u0003#\u0011\u0000\u0efb\u0efc\u0003!\u0010\u0000\u0efc\u01ec\u0001\u0000"+ - "\u0000\u0000\u0efd\u0efe\u0003\u000f\u0007\u0000\u0efe\u0eff\u00035\u001a"+ - "\u0000\u0eff\u0f00\u0003-\u0016\u0000\u0f00\u0f01\u0003\u000f\u0007\u0000"+ - "\u0f01\u0f02\u0003)\u0014\u0000\u0f02\u0f03\u0003!\u0010\u0000\u0f03\u0f04"+ - "\u0003\u0007\u0003\u0000\u0f04\u0f05\u0003\u001d\u000e\u0000\u0f05\u01ee"+ - "\u0001\u0000\u0000\u0000\u0f06\u0f07\u0003\u000f\u0007\u0000\u0f07\u0f08"+ - "\u00035\u001a\u0000\u0f08\u0f09\u0003-\u0016\u0000\u0f09\u0f0a\u0003)"+ - "\u0014\u0000\u0f0a\u0f0b\u0003\u0007\u0003\u0000\u0f0b\u0f0c\u0003\u000b"+ - "\u0005\u0000\u0f0c\u0f0d\u0003-\u0016\u0000\u0f0d\u01f0\u0001\u0000\u0000"+ - "\u0000\u0f0e\u0f0f\u0003\u0011\b\u0000\u0f0f\u0f10\u0003\u0007\u0003\u0000"+ - "\u0f10\u0f11\u0003\u001d\u000e\u0000\u0f11\u0f12\u0003+\u0015\u0000\u0f12"+ - "\u0f13\u0003\u000f\u0007\u0000\u0f13\u01f2\u0001\u0000\u0000\u0000\u0f14"+ - "\u0f15\u0003\u0011\b\u0000\u0f15\u0f16\u0003\u000f\u0007\u0000\u0f16\u0f17"+ - "\u0003-\u0016\u0000\u0f17\u0f18\u0003\u000b\u0005\u0000\u0f18\u0f19\u0003"+ - "\u0015\n\u0000\u0f19\u01f4\u0001\u0000\u0000\u0000\u0f1a\u0f1b\u0003\u0011"+ - "\b\u0000\u0f1b\u0f1c\u0003\u0017\u000b\u0000\u0f1c\u0f1d\u0003\u000f\u0007"+ - "\u0000\u0f1d\u0f1e\u0003\u001d\u000e\u0000\u0f1e\u0f1f\u0003\r\u0006\u0000"+ - "\u0f1f\u0f20\u0003+\u0015\u0000\u0f20\u01f6\u0001\u0000\u0000\u0000\u0f21"+ - "\u0f22\u0003\u0011\b\u0000\u0f22\u0f23\u0003\u0017\u000b\u0000\u0f23\u0f24"+ - "\u0003\u001d\u000e\u0000\u0f24\u0f25\u0003-\u0016\u0000\u0f25\u0f26\u0003"+ - "\u000f\u0007\u0000\u0f26\u0f27\u0003)\u0014\u0000\u0f27\u01f8\u0001\u0000"+ - "\u0000\u0000\u0f28\u0f29\u0003\u0011\b\u0000\u0f29\u0f2a\u0003\u0017\u000b"+ - "\u0000\u0f2a\u0f2b\u0003!\u0010\u0000\u0f2b\u0f2c\u0003\u0007\u0003\u0000"+ - "\u0f2c\u0f2d\u0003\u001d\u000e\u0000\u0f2d\u01fa\u0001\u0000\u0000\u0000"+ - "\u0f2e\u0f2f\u0003\u0011\b\u0000\u0f2f\u0f30\u0003\u0017\u000b\u0000\u0f30"+ - "\u0f31\u0003)\u0014\u0000\u0f31\u0f32\u0003+\u0015\u0000\u0f32\u0f33\u0003"+ - "-\u0016\u0000\u0f33\u01fc\u0001\u0000\u0000\u0000\u0f34\u0f35\u0003\u0011"+ - "\b\u0000\u0f35\u0f36\u0003\u001d\u000e\u0000\u0f36\u0f37\u0003#\u0011"+ - "\u0000\u0f37\u0f38\u0003\u0007\u0003\u0000\u0f38\u0f39\u0003-\u0016\u0000"+ - "\u0f39\u01fe\u0001\u0000\u0000\u0000\u0f3a\u0f3b\u0003\u0011\b\u0000\u0f3b"+ - "\u0f3c\u0003\u001d\u000e\u0000\u0f3c\u0f3d\u0003#\u0011\u0000\u0f3d\u0f3e"+ - "\u0003#\u0011\u0000\u0f3e\u0f3f\u0003)\u0014\u0000\u0f3f\u0200\u0001\u0000"+ - "\u0000\u0000\u0f40\u0f41\u0003\u0011\b\u0000\u0f41\u0f42\u0003#\u0011"+ - "\u0000\u0f42\u0f43\u0003\u001d\u000e\u0000\u0f43\u0f44\u0003\u001d\u000e"+ - "\u0000\u0f44\u0f45\u0003#\u0011\u0000\u0f45\u0f46\u00033\u0019\u0000\u0f46"+ - "\u0f47\u0003\u0017\u000b\u0000\u0f47\u0f48\u0003!\u0010\u0000\u0f48\u0f49"+ - "\u0003\u0013\t\u0000\u0f49\u0202\u0001\u0000\u0000\u0000\u0f4a\u0f4b\u0003"+ - "\u0011\b\u0000\u0f4b\u0f4c\u0003#\u0011\u0000\u0f4c\u0f4d\u0003)\u0014"+ - "\u0000\u0f4d\u0204\u0001\u0000\u0000\u0000\u0f4e\u0f4f\u0003\u0011\b\u0000"+ - "\u0f4f\u0f50\u0003#\u0011\u0000\u0f50\u0f51\u0003)\u0014\u0000\u0f51\u0f52"+ - "\u0003\u000b\u0005\u0000\u0f52\u0f53\u0003\u000f\u0007\u0000\u0f53\u0206"+ - "\u0001\u0000\u0000\u0000\u0f54\u0f55\u0003\u0011\b\u0000\u0f55\u0f56\u0003"+ - "#\u0011\u0000\u0f56\u0f57\u0003)\u0014\u0000\u0f57\u0f58\u0003\u000f\u0007"+ - "\u0000\u0f58\u0f59\u0003\u0017\u000b\u0000\u0f59\u0f5a\u0003\u0013\t\u0000"+ - "\u0f5a\u0f5b\u0003!\u0010\u0000\u0f5b\u0208\u0001\u0000\u0000\u0000\u0f5c"+ - "\u0f5d\u0003\u0011\b\u0000\u0f5d\u0f5e\u0003#\u0011\u0000\u0f5e\u0f5f"+ - "\u0003)\u0014\u0000\u0f5f\u0f60\u0003\u001f\u000f\u0000\u0f60\u0f61\u0003"+ - "\u0007\u0003\u0000\u0f61\u0f62\u0003-\u0016\u0000\u0f62\u020a\u0001\u0000"+ - "\u0000\u0000\u0f63\u0f64\u0003\u0011\b\u0000\u0f64\u0f65\u0003#\u0011"+ - "\u0000\u0f65\u0f66\u0003)\u0014\u0000\u0f66\u0f67\u0003-\u0016\u0000\u0f67"+ - "\u0f68\u0003)\u0014\u0000\u0f68\u0f69\u0003\u0007\u0003\u0000\u0f69\u0f6a"+ - "\u0003!\u0010\u0000\u0f6a\u020c\u0001\u0000\u0000\u0000\u0f6b\u0f6c\u0003"+ - "\u0011\b\u0000\u0f6c\u0f6d\u0003#\u0011\u0000\u0f6d\u0f6e\u0003)\u0014"+ - "\u0000\u0f6e\u0f6f\u00033\u0019\u0000\u0f6f\u0f70\u0003\u0007\u0003\u0000"+ - "\u0f70\u0f71\u0003)\u0014\u0000\u0f71\u0f72\u0003\r\u0006\u0000\u0f72"+ - "\u020e\u0001\u0000\u0000\u0000\u0f73\u0f74\u0003\u0011\b\u0000\u0f74\u0f75"+ - "\u0003#\u0011\u0000\u0f75\u0f76\u0003/\u0017\u0000\u0f76\u0f77\u0003!"+ - "\u0010\u0000\u0f77\u0f78\u0003\r\u0006\u0000\u0f78\u0210\u0001\u0000\u0000"+ - "\u0000\u0f79\u0f7a\u0003\u0011\b\u0000\u0f7a\u0f7b\u0003)\u0014\u0000"+ - "\u0f7b\u0f7c\u0003\u000f\u0007\u0000\u0f7c\u0f7d\u0003\u000f\u0007\u0000"+ - "\u0f7d\u0212\u0001\u0000\u0000\u0000\u0f7e\u0f7f\u0003\u0011\b\u0000\u0f7f"+ - "\u0f80\u0003)\u0014\u0000\u0f80\u0f81\u0003\u000f\u0007\u0000\u0f81\u0f82"+ - "\u0003\u000f\u0007\u0000\u0f82\u0f83\u00039\u001c\u0000\u0f83\u0f84\u0003"+ - "\u000f\u0007\u0000\u0f84\u0214\u0001\u0000\u0000\u0000\u0f85\u0f86\u0003"+ - "\u0011\b\u0000\u0f86\u0f87\u0003)\u0014\u0000\u0f87\u0f88\u0003#\u0011"+ - "\u0000\u0f88\u0f89\u0003\u001f\u000f\u0000\u0f89\u0216\u0001\u0000\u0000"+ - "\u0000\u0f8a\u0f8b\u0003\u0011\b\u0000\u0f8b\u0f8c\u0003/\u0017\u0000"+ - "\u0f8c\u0f8d\u0003\u001d\u000e\u0000\u0f8d\u0f8e\u0003\u001d\u000e\u0000"+ - "\u0f8e\u0218\u0001\u0000\u0000\u0000\u0f8f\u0f90\u0003\u0011\b\u0000\u0f90"+ - "\u0f91\u0003/\u0017\u0000\u0f91\u0f92\u0003!\u0010\u0000\u0f92\u0f93\u0003"+ - "\u000b\u0005\u0000\u0f93\u0f94\u0003-\u0016\u0000\u0f94\u0f95\u0003\u0017"+ - "\u000b\u0000\u0f95\u0f96\u0003#\u0011\u0000\u0f96\u0f97\u0003!\u0010\u0000"+ - "\u0f97\u021a\u0001\u0000\u0000\u0000\u0f98\u0f99\u0003\u0011\b\u0000\u0f99"+ - "\u0f9a\u0003/\u0017\u0000\u0f9a\u0f9b\u0003+\u0015\u0000\u0f9b\u0f9c\u0003"+ - "\u0017\u000b\u0000\u0f9c\u0f9d\u0003#\u0011\u0000\u0f9d\u0f9e\u0003!\u0010"+ - "\u0000\u0f9e\u021c\u0001\u0000\u0000\u0000\u0f9f\u0fa0\u0003\u0013\t\u0000"+ - "\u0fa0\u021e\u0001\u0000\u0000\u0000\u0fa1\u0fa2\u0003\u0013\t\u0000\u0fa2"+ - "\u0fa3\u0003\u000f\u0007\u0000\u0fa3\u0fa4\u0003!\u0010\u0000\u0fa4\u0fa5"+ - "\u0003\u000f\u0007\u0000\u0fa5\u0fa6\u0003)\u0014\u0000\u0fa6\u0fa7\u0003"+ - "\u0007\u0003\u0000\u0fa7\u0fa8\u0003\u001d\u000e\u0000\u0fa8\u0220\u0001"+ - "\u0000\u0000\u0000\u0fa9\u0faa\u0003\u0013\t\u0000\u0faa\u0fab\u0003\u000f"+ - "\u0007\u0000\u0fab\u0fac\u0003!\u0010\u0000\u0fac\u0fad\u0003\u000f\u0007"+ - "\u0000\u0fad\u0fae\u0003)\u0014\u0000\u0fae\u0faf\u0003\u0007\u0003\u0000"+ - "\u0faf\u0fb0\u0003-\u0016\u0000\u0fb0\u0fb1\u0003\u000f\u0007\u0000\u0fb1"+ - "\u0fb2\u0003\r\u0006\u0000\u0fb2\u0222\u0001\u0000\u0000\u0000\u0fb3\u0fb4"+ - "\u0003\u0013\t\u0000\u0fb4\u0fb5\u0003\u000f\u0007\u0000\u0fb5\u0fb6\u0003"+ - "-\u0016\u0000\u0fb6\u0224\u0001\u0000\u0000\u0000\u0fb7\u0fb8\u0003\u0013"+ - "\t\u0000\u0fb8\u0fb9\u0003\u001d\u000e\u0000\u0fb9\u0fba\u0003#\u0011"+ - "\u0000\u0fba\u0fbb\u0003\t\u0004\u0000\u0fbb\u0fbc\u0003\u0007\u0003\u0000"+ - "\u0fbc\u0fbd\u0003\u001d\u000e\u0000\u0fbd\u0226\u0001\u0000\u0000\u0000"+ - "\u0fbe\u0fbf\u0003\u0013\t\u0000\u0fbf\u0fc0\u0003#\u0011\u0000\u0fc0"+ - "\u0228\u0001\u0000\u0000\u0000\u0fc1\u0fc2\u0003\u0013\t\u0000\u0fc2\u0fc3"+ - "\u0003#\u0011\u0000\u0fc3\u0fc4\u0003-\u0016\u0000\u0fc4\u0fc5\u0003#"+ - "\u0011\u0000\u0fc5\u022a\u0001\u0000\u0000\u0000\u0fc6\u0fc7\u0003\u0013"+ - "\t\u0000\u0fc7\u0fc8\u0003)\u0014\u0000\u0fc8\u0fc9\u0003\u0007\u0003"+ - "\u0000\u0fc9\u0fca\u0003!\u0010\u0000\u0fca\u0fcb\u0003-\u0016\u0000\u0fcb"+ - "\u022c\u0001\u0000\u0000\u0000\u0fcc\u0fcd\u0003\u0013\t\u0000\u0fcd\u0fce"+ - "\u0003)\u0014\u0000\u0fce\u0fcf\u0003\u0007\u0003\u0000\u0fcf\u0fd0\u0003"+ - "!\u0010\u0000\u0fd0\u0fd1\u0003-\u0016\u0000\u0fd1\u0fd2\u0003\u000f\u0007"+ - "\u0000\u0fd2\u0fd3\u0003\r\u0006\u0000\u0fd3\u022e\u0001\u0000\u0000\u0000"+ - "\u0fd4\u0fd5\u0003\u0013\t\u0000\u0fd5\u0fd6\u0003)\u0014\u0000\u0fd6"+ - "\u0fd7\u0003\u000f\u0007\u0000\u0fd7\u0fd8\u0003\u0007\u0003\u0000\u0fd8"+ - "\u0fd9\u0003-\u0016\u0000\u0fd9\u0fda\u0003\u000f\u0007\u0000\u0fda\u0fdb"+ - "\u0003+\u0015\u0000\u0fdb\u0fdc\u0003-\u0016\u0000\u0fdc\u0230\u0001\u0000"+ - "\u0000\u0000\u0fdd"; + "\u02f3\u101b\u0001\u0000\u0000\u0000\u02f5\u1020\u0001\u0000\u0000\u0000"+ + "\u02f7\u1029\u0001\u0000\u0000\u0000\u02f9\u1034\u0001\u0000\u0000\u0000"+ + "\u02fb\u103c\u0001\u0000\u0000\u0000\u02fd\u1041\u0001\u0000\u0000\u0000"+ + "\u02ff\u1049\u0001\u0000\u0000\u0000\u0301\u104f\u0001\u0000\u0000\u0000"+ + "\u0303\u1053\u0001\u0000\u0000\u0000\u0305\u1058\u0001\u0000\u0000\u0000"+ + "\u0307\u105c\u0001\u0000\u0000\u0000\u0309\u1061\u0001\u0000\u0000\u0000"+ + "\u030b\u1069\u0001\u0000\u0000\u0000\u030d\u1070\u0001\u0000\u0000\u0000"+ + "\u030f\u1074\u0001\u0000\u0000\u0000\u0311\u107c\u0001\u0000\u0000\u0000"+ + "\u0313\u1081\u0001\u0000\u0000\u0000\u0315\u108b\u0001\u0000\u0000\u0000"+ + "\u0317\u1094\u0001\u0000\u0000\u0000\u0319\u1098\u0001\u0000\u0000\u0000"+ + "\u031b\u10a0\u0001\u0000\u0000\u0000\u031d\u10a7\u0001\u0000\u0000\u0000"+ + "\u031f\u10af\u0001\u0000\u0000\u0000\u0321\u10b5\u0001\u0000\u0000\u0000"+ + "\u0323\u10be\u0001\u0000\u0000\u0000\u0325\u10c4\u0001\u0000\u0000\u0000"+ + "\u0327\u10c8\u0001\u0000\u0000\u0000\u0329\u10d0\u0001\u0000\u0000\u0000"+ + "\u032b\u10d9\u0001\u0000\u0000\u0000\u032d\u10df\u0001\u0000\u0000\u0000"+ + "\u032f\u10e8\u0001\u0000\u0000\u0000\u0331\u10ee\u0001\u0000\u0000\u0000"+ + "\u0333\u10f3\u0001\u0000\u0000\u0000\u0335\u10fa\u0001\u0000\u0000\u0000"+ + "\u0337\u1102\u0001\u0000\u0000\u0000\u0339\u110a\u0001\u0000\u0000\u0000"+ + "\u033b\u1113\u0001\u0000\u0000\u0000\u033d\u111d\u0001\u0000\u0000\u0000"+ + "\u033f\u1122\u0001\u0000\u0000\u0000\u0341\u1126\u0001\u0000\u0000\u0000"+ + "\u0343\u112c\u0001\u0000\u0000\u0000\u0345\u1135\u0001\u0000\u0000\u0000"+ + "\u0347\u113f\u0001\u0000\u0000\u0000\u0349\u1144\u0001\u0000\u0000\u0000"+ + "\u034b\u114e\u0001\u0000\u0000\u0000\u034d\u1154\u0001\u0000\u0000\u0000"+ + "\u034f\u1159\u0001\u0000\u0000\u0000\u0351\u1160\u0001\u0000\u0000\u0000"+ + "\u0353\u1168\u0001\u0000\u0000\u0000\u0355\u1176\u0001\u0000\u0000\u0000"+ + "\u0357\u1181\u0001\u0000\u0000\u0000\u0359\u1188\u0001\u0000\u0000\u0000"+ + "\u035b\u119b\u0001\u0000\u0000\u0000\u035d\u11b7\u0001\u0000\u0000\u0000"+ + "\u035f\u11d2\u0001\u0000\u0000\u0000\u0361\u11d8\u0001\u0000\u0000\u0000"+ + "\u0363\u11e5\u0001\u0000\u0000\u0000\u0365\u11ef\u0001\u0000\u0000\u0000"+ + "\u0367\u11fa\u0001\u0000\u0000\u0000\u0369\u1204\u0001\u0000\u0000\u0000"+ + "\u036b\u120e\u0001\u0000\u0000\u0000\u036d\u1217\u0001\u0000\u0000\u0000"+ + "\u036f\u121d\u0001\u0000\u0000\u0000\u0371\u1225\u0001\u0000\u0000\u0000"+ + "\u0373\u1232\u0001\u0000\u0000\u0000\u0375\u1237\u0001\u0000\u0000\u0000"+ + "\u0377\u123f\u0001\u0000\u0000\u0000\u0379\u1246\u0001\u0000\u0000\u0000"+ + "\u037b\u124d\u0001\u0000\u0000\u0000\u037d\u1258\u0001\u0000\u0000\u0000"+ + "\u037f\u1262\u0001\u0000\u0000\u0000\u0381\u1269\u0001\u0000\u0000\u0000"+ + "\u0383\u1270\u0001\u0000\u0000\u0000\u0385\u1278\u0001\u0000\u0000\u0000"+ + "\u0387\u1280\u0001\u0000\u0000\u0000\u0389\u128a\u0001\u0000\u0000\u0000"+ + "\u038b\u1291\u0001\u0000\u0000\u0000\u038d\u1298\u0001\u0000\u0000\u0000"+ + "\u038f\u129f\u0001\u0000\u0000\u0000\u0391\u12ab\u0001\u0000\u0000\u0000"+ + "\u0393\u12af\u0001\u0000\u0000\u0000\u0395\u12b3\u0001\u0000\u0000\u0000"+ + "\u0397\u12b9\u0001\u0000\u0000\u0000\u0399\u12c6\u0001\u0000\u0000\u0000"+ + "\u039b\u12d2\u0001\u0000\u0000\u0000\u039d\u12d6\u0001\u0000\u0000\u0000"+ + "\u039f\u12da\u0001\u0000\u0000\u0000\u03a1\u12e3\u0001\u0000\u0000\u0000"+ + "\u03a3\u12eb\u0001\u0000\u0000\u0000\u03a5\u12f6\u0001\u0000\u0000\u0000"+ + "\u03a7\u12fc\u0001\u0000\u0000\u0000\u03a9\u1304\u0001\u0000\u0000\u0000"+ + "\u03ab\u130d\u0001\u0000\u0000\u0000\u03ad\u1311\u0001\u0000\u0000\u0000"+ + "\u03af\u1319\u0001\u0000\u0000\u0000\u03b1\u1324\u0001\u0000\u0000\u0000"+ + "\u03b3\u132d\u0001\u0000\u0000\u0000\u03b5\u1332\u0001\u0000\u0000\u0000"+ + "\u03b7\u1339\u0001\u0000\u0000\u0000\u03b9\u133e\u0001\u0000\u0000\u0000"+ + "\u03bb\u1345\u0001\u0000\u0000\u0000\u03bd\u134a\u0001\u0000\u0000\u0000"+ + "\u03bf\u1353\u0001\u0000\u0000\u0000\u03c1\u1358\u0001\u0000\u0000\u0000"+ + "\u03c3\u1364\u0001\u0000\u0000\u0000\u03c5\u136f\u0001\u0000\u0000\u0000"+ + "\u03c7\u1378\u0001\u0000\u0000\u0000\u03c9\u1380\u0001\u0000\u0000\u0000"+ + "\u03cb\u138e\u0001\u0000\u0000\u0000\u03cd\u1396\u0001\u0000\u0000\u0000"+ + "\u03cf\u13a1\u0001\u0000\u0000\u0000\u03d1\u13a8\u0001\u0000\u0000\u0000"+ + "\u03d3\u13af\u0001\u0000\u0000\u0000\u03d5\u13b6\u0001\u0000\u0000\u0000"+ + "\u03d7\u13bd\u0001\u0000\u0000\u0000\u03d9\u13c1\u0001\u0000\u0000\u0000"+ + "\u03db\u13c5\u0001\u0000\u0000\u0000\u03dd\u13ca\u0001\u0000\u0000\u0000"+ + "\u03df\u13cf\u0001\u0000\u0000\u0000\u03e1\u13d7\u0001\u0000\u0000\u0000"+ + "\u03e3\u13dd\u0001\u0000\u0000\u0000\u03e5\u13e7\u0001\u0000\u0000\u0000"+ + "\u03e7\u13ec\u0001\u0000\u0000\u0000\u03e9\u1400\u0001\u0000\u0000\u0000"+ + "\u03eb\u1412\u0001\u0000\u0000\u0000\u03ed\u1418\u0001\u0000\u0000\u0000"+ + "\u03ef\u1425\u0001\u0000\u0000\u0000\u03f1\u1430\u0001\u0000\u0000\u0000"+ + "\u03f3\u1436\u0001\u0000\u0000\u0000\u03f5\u143f\u0001\u0000\u0000\u0000"+ + "\u03f7\u1447\u0001\u0000\u0000\u0000\u03f9\u144b\u0001\u0000\u0000\u0000"+ + "\u03fb\u1457\u0001\u0000\u0000\u0000\u03fd\u145f\u0001\u0000\u0000\u0000"+ + "\u03ff\u1465\u0001\u0000\u0000\u0000\u0401\u146b\u0001\u0000\u0000\u0000"+ + "\u0403\u1473\u0001\u0000\u0000\u0000\u0405\u147b\u0001\u0000\u0000\u0000"+ + "\u0407\u1481\u0001\u0000\u0000\u0000\u0409\u1486\u0001\u0000\u0000\u0000"+ + "\u040b\u148d\u0001\u0000\u0000\u0000\u040d\u1493\u0001\u0000\u0000\u0000"+ + "\u040f\u1499\u0001\u0000\u0000\u0000\u0411\u14a2\u0001\u0000\u0000\u0000"+ + "\u0413\u14a8\u0001\u0000\u0000\u0000\u0415\u14ac\u0001\u0000\u0000\u0000"+ + "\u0417\u14b1\u0001\u0000\u0000\u0000\u0419\u14b8\u0001\u0000\u0000\u0000"+ + "\u041b\u14c0\u0001\u0000\u0000\u0000\u041d\u14ca\u0001\u0000\u0000\u0000"+ + "\u041f\u14d1\u0001\u0000\u0000\u0000\u0421\u14d6\u0001\u0000\u0000\u0000"+ + "\u0423\u14db\u0001\u0000\u0000\u0000\u0425\u14df\u0001\u0000\u0000\u0000"+ + "\u0427\u14e3\u0001\u0000\u0000\u0000\u0429\u14e8\u0001\u0000\u0000\u0000"+ + "\u042b\u14ed\u0001\u0000\u0000\u0000\u042d\u14f5\u0001\u0000\u0000\u0000"+ + "\u042f\u14fd\u0001\u0000\u0000\u0000\u0431\u1501\u0001\u0000\u0000\u0000"+ + "\u0433\u1505\u0001\u0000\u0000\u0000\u0435\u150f\u0001\u0000\u0000\u0000"+ + "\u0437\u1515\u0001\u0000\u0000\u0000\u0439\u1519\u0001\u0000\u0000\u0000"+ + "\u043b\u151d\u0001\u0000\u0000\u0000\u043d\u1520\u0001\u0000\u0000\u0000"+ + "\u043f\u1526\u0001\u0000\u0000\u0000\u0441\u1530\u0001\u0000\u0000\u0000"+ + "\u0443\u1534\u0001\u0000\u0000\u0000\u0445\u1537\u0001\u0000\u0000\u0000"+ + "\u0447\u153d\u0001\u0000\u0000\u0000\u0449\u1545\u0001\u0000\u0000\u0000"+ + "\u044b\u154b\u0001\u0000\u0000\u0000\u044d\u1551\u0001\u0000\u0000\u0000"+ + "\u044f\u1556\u0001\u0000\u0000\u0000\u0451\u155b\u0001\u0000\u0000\u0000"+ + "\u0453\u1566\u0001\u0000\u0000\u0000\u0455\u156c\u0001\u0000\u0000\u0000"+ + "\u0457\u1579\u0001\u0000\u0000\u0000\u0459\u1580\u0001\u0000\u0000\u0000"+ + "\u045b\u1588\u0001\u0000\u0000\u0000\u045d\u158d\u0001\u0000\u0000\u0000"+ + "\u045f\u1593\u0001\u0000\u0000\u0000\u0461\u1598\u0001\u0000\u0000\u0000"+ + "\u0463\u159e\u0001\u0000\u0000\u0000\u0465\u15a3\u0001\u0000\u0000\u0000"+ + "\u0467\u15a9\u0001\u0000\u0000\u0000\u0469\u15af\u0001\u0000\u0000\u0000"+ + "\u046b\u15b6\u0001\u0000\u0000\u0000\u046d\u15ba\u0001\u0000\u0000\u0000"+ + "\u046f\u15bf\u0001\u0000\u0000\u0000\u0471\u15c3\u0001\u0000\u0000\u0000"+ + "\u0473\u15c8\u0001\u0000\u0000\u0000\u0475\u15cc\u0001\u0000\u0000\u0000"+ + "\u0477\u15d1\u0001\u0000\u0000\u0000\u0479\u15d5\u0001\u0000\u0000\u0000"+ + "\u047b\u15da\u0001\u0000\u0000\u0000\u047d\u15df\u0001\u0000\u0000\u0000"+ + "\u047f\u15e4\u0001\u0000\u0000\u0000\u0481\u15e9\u0001\u0000\u0000\u0000"+ + "\u0483\u15ef\u0001\u0000\u0000\u0000\u0485\u15f5\u0001\u0000\u0000\u0000"+ + "\u0487\u15fb\u0001\u0000\u0000\u0000\u0489\u1606\u0001\u0000\u0000\u0000"+ + "\u048b\u1612\u0001\u0000\u0000\u0000\u048d\u1623\u0001\u0000\u0000\u0000"+ + "\u048f\u1629\u0001\u0000\u0000\u0000\u0491\u1636\u0001\u0000\u0000\u0000"+ + "\u0493\u163c\u0001\u0000\u0000\u0000\u0495\u1642\u0001\u0000\u0000\u0000"+ + "\u0497\u1648\u0001\u0000\u0000\u0000\u0499\u164c\u0001\u0000\u0000\u0000"+ + "\u049b\u1653\u0001\u0000\u0000\u0000\u049d\u165d\u0001\u0000\u0000\u0000"+ + "\u049f\u1664\u0001\u0000\u0000\u0000\u04a1\u166c\u0001\u0000\u0000\u0000"+ + "\u04a3\u1673\u0001\u0000\u0000\u0000\u04a5\u1678\u0001\u0000\u0000\u0000"+ + "\u04a7\u167e\u0001\u0000\u0000\u0000\u04a9\u1682\u0001\u0000\u0000\u0000"+ + "\u04ab\u168e\u0001\u0000\u0000\u0000\u04ad\u16a1\u0001\u0000\u0000\u0000"+ + "\u04af\u16ad\u0001\u0000\u0000\u0000\u04b1\u16bb\u0001\u0000\u0000\u0000"+ + "\u04b3\u16ca\u0001\u0000\u0000\u0000\u04b5\u16d7\u0001\u0000\u0000\u0000"+ + "\u04b7\u16e4\u0001\u0000\u0000\u0000\u04b9\u16f0\u0001\u0000\u0000\u0000"+ + "\u04bb\u16fd\u0001\u0000\u0000\u0000\u04bd\u170c\u0001\u0000\u0000\u0000"+ + "\u04bf\u171b\u0001\u0000\u0000\u0000\u04c1\u1731\u0001\u0000\u0000\u0000"+ + "\u04c3\u1747\u0001\u0000\u0000\u0000\u04c5\u1755\u0001\u0000\u0000\u0000"+ + "\u04c7\u175c\u0001\u0000\u0000\u0000\u04c9\u1761\u0001\u0000\u0000\u0000"+ + "\u04cb\u1767\u0001\u0000\u0000\u0000\u04cd\u1772\u0001\u0000\u0000\u0000"+ + "\u04cf\u177e\u0001\u0000\u0000\u0000\u04d1\u178e\u0001\u0000\u0000\u0000"+ + "\u04d3\u179e\u0001\u0000\u0000\u0000\u04d5\u17a5\u0001\u0000\u0000\u0000"+ + "\u04d7\u17ac\u0001\u0000\u0000\u0000\u04d9\u17b5\u0001\u0000\u0000\u0000"+ + "\u04db\u17bc\u0001\u0000\u0000\u0000\u04dd\u17c6\u0001\u0000\u0000\u0000"+ + "\u04df\u17cd\u0001\u0000\u0000\u0000\u04e1\u17d1\u0001\u0000\u0000\u0000"+ + "\u04e3\u17e1\u0001\u0000\u0000\u0000\u04e5\u17ea\u0001\u0000\u0000\u0000"+ + "\u04e7\u17f4\u0001\u0000\u0000\u0000\u04e9\u17ff\u0001\u0000\u0000\u0000"+ + "\u04eb\u1808\u0001\u0000\u0000\u0000\u04ed\u1815\u0001\u0000\u0000\u0000"+ + "\u04ef\u1823\u0001\u0000\u0000\u0000\u04f1\u1834\u0001\u0000\u0000\u0000"+ + "\u04f3\u183e\u0001\u0000\u0000\u0000\u04f5\u184c\u0001\u0000\u0000\u0000"+ + "\u04f7\u1856\u0001\u0000\u0000\u0000\u04f9\u1865\u0001\u0000\u0000\u0000"+ + "\u04fb\u1876\u0001\u0000\u0000\u0000\u04fd\u187a\u0001\u0000\u0000\u0000"+ + "\u04ff\u188e\u0001\u0000\u0000\u0000\u0501\u1898\u0001\u0000\u0000\u0000"+ + "\u0503\u18ae\u0001\u0000\u0000\u0000\u0505\u18bb\u0001\u0000\u0000\u0000"+ + "\u0507\u18c3\u0001\u0000\u0000\u0000\u0509\u18cb\u0001\u0000\u0000\u0000"+ + "\u050b\u18d5\u0001\u0000\u0000\u0000\u050d\u18e2\u0001\u0000\u0000\u0000"+ + "\u050f\u18e6\u0001\u0000\u0000\u0000\u0511\u18ea\u0001\u0000\u0000\u0000"+ + "\u0513\u18ec\u0001\u0000\u0000\u0000\u0515\u18ef\u0001\u0000\u0000\u0000"+ + "\u0517\u18f8\u0001\u0000\u0000\u0000\u0519\u18fb\u0001\u0000\u0000\u0000"+ + "\u051b\u1904\u0001\u0000\u0000\u0000\u051d\u1908\u0001\u0000\u0000\u0000"+ + "\u051f\u190c\u0001\u0000\u0000\u0000\u0521\u1910\u0001\u0000\u0000\u0000"+ + "\u0523\u1914\u0001\u0000\u0000\u0000\u0525\u1917\u0001\u0000\u0000\u0000"+ + "\u0527\u1925\u0001\u0000\u0000\u0000\u0529\u192b\u0001\u0000\u0000\u0000"+ + "\u052b\u192e\u0001\u0000\u0000\u0000\u052d\u1932\u0001\u0000\u0000\u0000"+ + "\u052f\u193b\u0001\u0000\u0000\u0000\u0531\u1942\u0001\u0000\u0000\u0000"+ + "\u0533\u1945\u0001\u0000\u0000\u0000\u0535\u194d\u0001\u0000\u0000\u0000"+ + "\u0537\u1950\u0001\u0000\u0000\u0000\u0539\u1953\u0001\u0000\u0000\u0000"+ + "\u053b\u1956\u0001\u0000\u0000\u0000\u053d\u195e\u0001\u0000\u0000\u0000"+ + "\u053f\u1961\u0001\u0000\u0000\u0000\u0541\u1964\u0001\u0000\u0000\u0000"+ + "\u0543\u1966\u0001\u0000\u0000\u0000\u0545\u1988\u0001\u0000\u0000\u0000"+ + "\u0547\u198b\u0001\u0000\u0000\u0000\u0549\u198f\u0001\u0000\u0000\u0000"+ + "\u054b\u199f\u0001\u0000\u0000\u0000\u054d\u19aa\u0001\u0000\u0000\u0000"+ + "\u054f\u19ae\u0001\u0000\u0000\u0000\u0551\u19b9\u0001\u0000\u0000\u0000"+ + "\u0553\u19e0\u0001\u0000\u0000\u0000\u0555\u1a13\u0001\u0000\u0000\u0000"+ + "\u0557\u1a2b\u0001\u0000\u0000\u0000\u0559\u1a2e\u0001\u0000\u0000\u0000"+ + "\u055b\u1a30\u0001\u0000\u0000\u0000\u055d\u1a35\u0001\u0000\u0000\u0000"+ + "\u055f\u1a57\u0001\u0000\u0000\u0000\u0561\u1a5a\u0001\u0000\u0000\u0000"+ + "\u0563\u1a5f\u0001\u0000\u0000\u0000\u0565\u1a6c\u0001\u0000\u0000\u0000"+ + "\u0567\u1a6f\u0001\u0000\u0000\u0000\u0569\u1a74\u0001\u0000\u0000\u0000"+ + "\u056b\u1a7a\u0001\u0000\u0000\u0000\u056d\u1a7f\u0001\u0000\u0000\u0000"+ + "\u056f\u1a84\u0001\u0000\u0000\u0000\u0571\u1a95\u0001\u0000\u0000\u0000"+ + "\u0573\u1a97\u0001\u0000\u0000\u0000\u0575\u0576\u0005#\u0000\u0000\u0576"+ + "\u0577\u0005{\u0000\u0000\u0577\u0578\u0001\u0000\u0000\u0000\u0578\u0579"+ + "\u0003\u0007\u0001\u0000\u0579\u057a\u0005}\u0000\u0000\u057a\u0006\u0001"+ + "\u0000\u0000\u0000\u057b\u057d\t\u0000\u0000\u0000\u057c\u057b\u0001\u0000"+ + "\u0000\u0000\u057d\u0580\u0001\u0000\u0000\u0000\u057e\u057f\u0001\u0000"+ + "\u0000\u0000\u057e\u057c\u0001\u0000\u0000\u0000\u057f\b\u0001\u0000\u0000"+ + "\u0000\u0580\u057e\u0001\u0000\u0000\u0000\u0581\u0582\u0005$\u0000\u0000"+ + "\u0582\n\u0001\u0000\u0000\u0000\u0583\u0584\u0005(\u0000\u0000\u0584"+ + "\f\u0001\u0000\u0000\u0000\u0585\u0586\u0005)\u0000\u0000\u0586\u000e"+ + "\u0001\u0000\u0000\u0000\u0587\u0588\u0005[\u0000\u0000\u0588\u0010\u0001"+ + "\u0000\u0000\u0000\u0589\u058a\u0005]\u0000\u0000\u058a\u0012\u0001\u0000"+ + "\u0000\u0000\u058b\u058c\u0005,\u0000\u0000\u058c\u0014\u0001\u0000\u0000"+ + "\u0000\u058d\u058e\u0005;\u0000\u0000\u058e\u0016\u0001\u0000\u0000\u0000"+ + "\u058f\u0590\u0005:\u0000\u0000\u0590\u0018\u0001\u0000\u0000\u0000\u0591"+ + "\u0592\u0005?\u0000\u0000\u0592\u001a\u0001\u0000\u0000\u0000\u0593\u0594"+ + "\u0005*\u0000\u0000\u0594\u001c\u0001\u0000\u0000\u0000\u0595\u0596\u0005"+ + "=\u0000\u0000\u0596\u001e\u0001\u0000\u0000\u0000\u0597\u0598\u0005.\u0000"+ + "\u0000\u0598 \u0001\u0000\u0000\u0000\u0599\u059a\u0005+\u0000\u0000\u059a"+ + "\"\u0001\u0000\u0000\u0000\u059b\u059c\u0005-\u0000\u0000\u059c$\u0001"+ + "\u0000\u0000\u0000\u059d\u059e\u0005/\u0000\u0000\u059e&\u0001\u0000\u0000"+ + "\u0000\u059f\u05a0\u0005^\u0000\u0000\u05a0(\u0001\u0000\u0000\u0000\u05a1"+ + "\u05a2\u0005<\u0000\u0000\u05a2*\u0001\u0000\u0000\u0000\u05a3\u05a4\u0005"+ + ">\u0000\u0000\u05a4,\u0001\u0000\u0000\u0000\u05a5\u05a6\u0005<\u0000"+ + "\u0000\u05a6\u05a7\u0005<\u0000\u0000\u05a7.\u0001\u0000\u0000\u0000\u05a8"+ + "\u05a9\u0005>\u0000\u0000\u05a9\u05aa\u0005>\u0000\u0000\u05aa0\u0001"+ + "\u0000\u0000\u0000\u05ab\u05ac\u0005:\u0000\u0000\u05ac\u05ad\u0005=\u0000"+ + "\u0000\u05ad2\u0001\u0000\u0000\u0000\u05ae\u05af\u0005<\u0000\u0000\u05af"+ + "\u05b0\u0005=\u0000\u0000\u05b04\u0001\u0000\u0000\u0000\u05b1\u05b2\u0005"+ + "=\u0000\u0000\u05b2\u05b3\u0005>\u0000\u0000\u05b36\u0001\u0000\u0000"+ + "\u0000\u05b4\u05b5\u0005>\u0000\u0000\u05b5\u05b6\u0005=\u0000\u0000\u05b6"+ + "8\u0001\u0000\u0000\u0000\u05b7\u05b8\u0005.\u0000\u0000\u05b8\u05b9\u0005"+ + ".\u0000\u0000\u05b9:\u0001\u0000\u0000\u0000\u05ba\u05bb\u0005<\u0000"+ + "\u0000\u05bb\u05bc\u0005>\u0000\u0000\u05bc<\u0001\u0000\u0000\u0000\u05bd"+ + "\u05be\u0005:\u0000\u0000\u05be\u05bf\u0005:\u0000\u0000\u05bf>\u0001"+ + "\u0000\u0000\u0000\u05c0\u05c1\u0005%\u0000\u0000\u05c1@\u0001\u0000\u0000"+ + "\u0000\u05c2\u05c4\u0005$\u0000\u0000\u05c3\u05c5\u0007\u0000\u0000\u0000"+ + "\u05c4\u05c3\u0001\u0000\u0000\u0000\u05c5\u05c6\u0001\u0000\u0000\u0000"+ + "\u05c6\u05c4\u0001\u0000\u0000\u0000\u05c6\u05c7\u0001\u0000\u0000\u0000"+ + "\u05c7B\u0001\u0000\u0000\u0000\u05c8\u05d8\u0003G!\u0000\u05c9\u05cd"+ + "\u0005+\u0000\u0000\u05ca\u05cb\u0005-\u0000\u0000\u05cb\u05cd\u0004\u001f"+ + "\u0000\u0000\u05cc\u05c9\u0001\u0000\u0000\u0000\u05cc\u05ca\u0001\u0000"+ + "\u0000\u0000\u05cd\u05ce\u0001\u0000\u0000\u0000\u05ce\u05cc\u0001\u0000"+ + "\u0000\u0000\u05ce\u05cf\u0001\u0000\u0000\u0000\u05cf\u05d3\u0001\u0000"+ + "\u0000\u0000\u05d0\u05d4\u0003G!\u0000\u05d1\u05d2\u0005/\u0000\u0000"+ + "\u05d2\u05d4\u0004\u001f\u0001\u0000\u05d3\u05d0\u0001\u0000\u0000\u0000"+ + "\u05d3\u05d1\u0001\u0000\u0000\u0000\u05d4\u05d8\u0001\u0000\u0000\u0000"+ + "\u05d5\u05d6\u0005/\u0000\u0000\u05d6\u05d8\u0004\u001f\u0002\u0000\u05d7"+ + "\u05c8\u0001\u0000\u0000\u0000\u05d7\u05cc\u0001\u0000\u0000\u0000\u05d7"+ + "\u05d5\u0001\u0000\u0000\u0000\u05d8\u05d9\u0001\u0000\u0000\u0000\u05d9"+ + "\u05d7\u0001\u0000\u0000\u0000\u05d9\u05da\u0001\u0000\u0000\u0000\u05da"+ + "\u05ee\u0001\u0000\u0000\u0000\u05db\u05ee\u0007\u0001\u0000\u0000\u05dc"+ + "\u05dd\u0005?\u0000\u0000\u05dd\u05ec\u0005#\u0000\u0000\u05de\u05df\u0005"+ + "?\u0000\u0000\u05df\u05ec\u0005-\u0000\u0000\u05e0\u05e1\u0005?\u0000"+ + "\u0000\u05e1\u05e2\u0005-\u0000\u0000\u05e2\u05ec\u0005|\u0000\u0000\u05e3"+ + "\u05e4\u0005?\u0000\u0000\u05e4\u05ec\u0005|\u0000\u0000\u05e5\u05e6\u0005"+ + "?\u0000\u0000\u05e6\u05e7\u0005|\u0000\u0000\u05e7\u05ec\u0005|\u0000"+ + "\u0000\u05e8\u05e9\u0005<\u0000\u0000\u05e9\u05ea\u0005?\u0000\u0000\u05ea"+ + "\u05ec\u0005>\u0000\u0000\u05eb\u05dc\u0001\u0000\u0000\u0000\u05eb\u05de"+ + "\u0001\u0000\u0000\u0000\u05eb\u05e0\u0001\u0000\u0000\u0000\u05eb\u05e3"+ + "\u0001\u0000\u0000\u0000\u05eb\u05e5\u0001\u0000\u0000\u0000\u05eb\u05e8"+ + "\u0001\u0000\u0000\u0000\u05ec\u05ee\u0001\u0000\u0000\u0000\u05ed\u05d7"+ + "\u0001\u0000\u0000\u0000\u05ed\u05db\u0001\u0000\u0000\u0000\u05ed\u05eb"+ + "\u0001\u0000\u0000\u0000\u05ee\u05ef\u0001\u0000\u0000\u0000\u05ef\u05f0"+ + "\u0006\u001f\u0000\u0000\u05f0D\u0001\u0000\u0000\u0000\u05f1\u05f7\u0003"+ + "I\"\u0000\u05f2\u05f3\u0005-\u0000\u0000\u05f3\u05f7\u0004 \u0003\u0000"+ + "\u05f4\u05f5\u0005/\u0000\u0000\u05f5\u05f7\u0004 \u0004\u0000\u05f6\u05f1"+ + "\u0001\u0000\u0000\u0000\u05f6\u05f2\u0001\u0000\u0000\u0000\u05f6\u05f4"+ + "\u0001\u0000\u0000\u0000\u05f7\u05fa\u0001\u0000\u0000\u0000\u05f8\u05f6"+ + "\u0001\u0000\u0000\u0000\u05f8\u05f9\u0001\u0000\u0000\u0000\u05f9\u05fb"+ + "\u0001\u0000\u0000\u0000\u05fa\u05f8\u0001\u0000\u0000\u0000\u05fb\u05fd"+ + "\u0003K#\u0000\u05fc\u05fe\u0003C\u001f\u0000\u05fd\u05fc\u0001\u0000"+ + "\u0000\u0000\u05fd\u05fe\u0001\u0000\u0000\u0000\u05fe\u0602\u0001\u0000"+ + "\u0000\u0000\u05ff\u0603\u0005+\u0000\u0000\u0600\u0601\u0005-\u0000\u0000"+ + "\u0601\u0603\u0004 \u0005\u0000\u0602\u05ff\u0001\u0000\u0000\u0000\u0602"+ + "\u0600\u0001\u0000\u0000\u0000\u0603\u0604\u0001\u0000\u0000\u0000\u0604"+ + "\u0602\u0001\u0000\u0000\u0000\u0604\u0605\u0001\u0000\u0000\u0000\u0605"+ + "\u0606\u0001\u0000\u0000\u0000\u0606\u0607\u0006 \u0001\u0000\u0607F\u0001"+ + "\u0000\u0000\u0000\u0608\u0609\u0007\u0002\u0000\u0000\u0609H\u0001\u0000"+ + "\u0000\u0000\u060a\u060b\u0007\u0003\u0000\u0000\u060bJ\u0001\u0000\u0000"+ + "\u0000\u060c\u060d\u0007\u0004\u0000\u0000\u060dL\u0001\u0000\u0000\u0000"+ + "\u060e\u060f\u0007\u0005\u0000\u0000\u060f\u0610\u0007\u0006\u0000\u0000"+ + "\u0610\u0611\u0007\u0006\u0000\u0000\u0611N\u0001\u0000\u0000\u0000\u0612"+ + "\u0613\u0007\u0005\u0000\u0000\u0613\u0614\u0007\u0007\u0000\u0000\u0614"+ + "\u0615\u0007\u0005\u0000\u0000\u0615\u0616\u0007\u0006\u0000\u0000\u0616"+ + "\u0617\u0007\b\u0000\u0000\u0617\u0618\u0007\t\u0000\u0000\u0618\u0619"+ + "\u0007\n\u0000\u0000\u0619P\u0001\u0000\u0000\u0000\u061a\u061b\u0007"+ + "\u0005\u0000\u0000\u061b\u061c\u0007\u0007\u0000\u0000\u061c\u061d\u0007"+ + "\u0005\u0000\u0000\u061d\u061e\u0007\u0006\u0000\u0000\u061e\u061f\u0007"+ + "\b\u0000\u0000\u061f\u0620\u0007\u000b\u0000\u0000\u0620\u0621\u0007\n"+ + "\u0000\u0000\u0621R\u0001\u0000\u0000\u0000\u0622\u0623\u0007\u0005\u0000"+ + "\u0000\u0623\u0624\u0007\u0007\u0000\u0000\u0624\u0625\u0007\f\u0000\u0000"+ + "\u0625T\u0001\u0000\u0000\u0000\u0626\u0627\u0007\u0005\u0000\u0000\u0627"+ + "\u0628\u0007\u0007\u0000\u0000\u0628\u0629\u0007\b\u0000\u0000\u0629V"+ + "\u0001\u0000\u0000\u0000\u062a\u062b\u0007\u0005\u0000\u0000\u062b\u062c"+ + "\u0007\r\u0000\u0000\u062c\u062d\u0007\r\u0000\u0000\u062d\u062e\u0007"+ + "\u0005\u0000\u0000\u062e\u062f\u0007\b\u0000\u0000\u062fX\u0001\u0000"+ + "\u0000\u0000\u0630\u0631\u0007\u0005\u0000\u0000\u0631\u0632\u0007\t\u0000"+ + "\u0000\u0632Z\u0001\u0000\u0000\u0000\u0633\u0634\u0007\u0005\u0000\u0000"+ + "\u0634\u0635\u0007\t\u0000\u0000\u0635\u0636\u0007\u000e\u0000\u0000\u0636"+ + "\\\u0001\u0000\u0000\u0000\u0637\u0638\u0007\u0005\u0000\u0000\u0638\u0639"+ + "\u0007\t\u0000\u0000\u0639\u063a\u0007\b\u0000\u0000\u063a\u063b\u0007"+ + "\u000f\u0000\u0000\u063b\u063c\u0007\u000f\u0000\u0000\u063c\u063d\u0007"+ + "\n\u0000\u0000\u063d\u063e\u0007\u0010\u0000\u0000\u063e\u063f\u0007\r"+ + "\u0000\u0000\u063f\u0640\u0007\u0011\u0000\u0000\u0640\u0641\u0007\u000e"+ + "\u0000\u0000\u0641^\u0001\u0000\u0000\u0000\u0642\u0643\u0007\u0012\u0000"+ + "\u0000\u0643\u0644\u0007\u0013\u0000\u0000\u0644\u0645\u0007\u0010\u0000"+ + "\u0000\u0645\u0646\u0007\u0014\u0000\u0000\u0646`\u0001\u0000\u0000\u0000"+ + "\u0647\u0648\u0007\u000e\u0000\u0000\u0648\u0649\u0007\u0005\u0000\u0000"+ + "\u0649\u064a\u0007\t\u0000\u0000\u064a\u064b\u0007\n\u0000\u0000\u064b"+ + "b\u0001\u0000\u0000\u0000\u064c\u064d\u0007\u000e\u0000\u0000\u064d\u064e"+ + "\u0007\u0005\u0000\u0000\u064e\u064f\u0007\t\u0000\u0000\u064f\u0650\u0007"+ + "\u0010\u0000\u0000\u0650d\u0001\u0000\u0000\u0000\u0651\u0652\u0007\u000e"+ + "\u0000\u0000\u0652\u0653\u0007\u0014\u0000\u0000\u0653\u0654\u0007\n\u0000"+ + "\u0000\u0654\u0655\u0007\u000e\u0000\u0000\u0655\u0656\u0007\u0015\u0000"+ + "\u0000\u0656f\u0001\u0000\u0000\u0000\u0657\u0658\u0007\u000e\u0000\u0000"+ + "\u0658\u0659\u0007\u0013\u0000\u0000\u0659\u065a\u0007\u0006\u0000\u0000"+ + "\u065a\u065b\u0007\u0006\u0000\u0000\u065b\u065c\u0007\u0005\u0000\u0000"+ + "\u065c\u065d\u0007\u0010\u0000\u0000\u065d\u065e\u0007\n\u0000\u0000\u065e"+ + "h\u0001\u0000\u0000\u0000\u065f\u0660\u0007\u000e\u0000\u0000\u0660\u0661"+ + "\u0007\u0013\u0000\u0000\u0661\u0662\u0007\u0006\u0000\u0000\u0662\u0663"+ + "\u0007\u0016\u0000\u0000\u0663\u0664\u0007\u000f\u0000\u0000\u0664\u0665"+ + "\u0007\u0007\u0000\u0000\u0665j\u0001\u0000\u0000\u0000\u0666\u0667\u0007"+ + "\u000e\u0000\u0000\u0667\u0668\u0007\u0013\u0000\u0000\u0668\u0669\u0007"+ + "\u0007\u0000\u0000\u0669\u066a\u0007\t\u0000\u0000\u066a\u066b\u0007\u0010"+ + "\u0000\u0000\u066b\u066c\u0007\r\u0000\u0000\u066c\u066d\u0007\u0005\u0000"+ + "\u0000\u066d\u066e\u0007\u0011\u0000\u0000\u066e\u066f\u0007\u0007\u0000"+ + "\u0000\u066f\u0670\u0007\u0010\u0000\u0000\u0670l\u0001\u0000\u0000\u0000"+ + "\u0671\u0672\u0007\u000e\u0000\u0000\u0672\u0673\u0007\r\u0000\u0000\u0673"+ + "\u0674\u0007\n\u0000\u0000\u0674\u0675\u0007\u0005\u0000\u0000\u0675\u0676"+ + "\u0007\u0010\u0000\u0000\u0676\u0677\u0007\n\u0000\u0000\u0677n\u0001"+ + "\u0000\u0000\u0000\u0678\u0679\u0007\u000e\u0000\u0000\u0679\u067a\u0007"+ + "\u0016\u0000\u0000\u067a\u067b\u0007\r\u0000\u0000\u067b\u067c\u0007\r"+ + "\u0000\u0000\u067c\u067d\u0007\n\u0000\u0000\u067d\u067e\u0007\u0007\u0000"+ + "\u0000\u067e\u067f\u0007\u0010\u0000\u0000\u067f\u0680\u0005_\u0000\u0000"+ + "\u0680\u0681\u0007\u000e\u0000\u0000\u0681\u0682\u0007\u0005\u0000\u0000"+ + "\u0682\u0683\u0007\u0010\u0000\u0000\u0683\u0684\u0007\u0005\u0000\u0000"+ + "\u0684\u0685\u0007\u0006\u0000\u0000\u0685\u0686\u0007\u0013\u0000\u0000"+ + "\u0686\u0687\u0007\u0017\u0000\u0000\u0687p\u0001\u0000\u0000\u0000\u0688"+ + "\u0689\u0007\u000e\u0000\u0000\u0689\u068a\u0007\u0016\u0000\u0000\u068a"+ + "\u068b\u0007\r\u0000\u0000\u068b\u068c\u0007\r\u0000\u0000\u068c\u068d"+ + "\u0007\n\u0000\u0000\u068d\u068e\u0007\u0007\u0000\u0000\u068e\u068f\u0007"+ + "\u0010\u0000\u0000\u068f\u0690\u0005_\u0000\u0000\u0690\u0691\u0007\f"+ + "\u0000\u0000\u0691\u0692\u0007\u0005\u0000\u0000\u0692\u0693\u0007\u0010"+ + "\u0000\u0000\u0693\u0694\u0007\n\u0000\u0000\u0694r\u0001\u0000\u0000"+ + "\u0000\u0695\u0696\u0007\u000e\u0000\u0000\u0696\u0697\u0007\u0016\u0000"+ + "\u0000\u0697\u0698\u0007\r\u0000\u0000\u0698\u0699\u0007\r\u0000\u0000"+ + "\u0699\u069a\u0007\n\u0000\u0000\u069a\u069b\u0007\u0007\u0000\u0000\u069b"+ + "\u069c\u0007\u0010\u0000\u0000\u069c\u069d\u0005_\u0000\u0000\u069d\u069e"+ + "\u0007\r\u0000\u0000\u069e\u069f\u0007\u0013\u0000\u0000\u069f\u06a0\u0007"+ + "\u0006\u0000\u0000\u06a0\u06a1\u0007\n\u0000\u0000\u06a1t\u0001\u0000"+ + "\u0000\u0000\u06a2\u06a3\u0007\u000e\u0000\u0000\u06a3\u06a4\u0007\u0016"+ + "\u0000\u0000\u06a4\u06a5\u0007\r\u0000\u0000\u06a5\u06a6\u0007\r\u0000"+ + "\u0000\u06a6\u06a7\u0007\n\u0000\u0000\u06a7\u06a8\u0007\u0007\u0000\u0000"+ + "\u06a8\u06a9\u0007\u0010\u0000\u0000\u06a9\u06aa\u0005_\u0000\u0000\u06aa"+ + "\u06ab\u0007\u0010\u0000\u0000\u06ab\u06ac\u0007\u0011\u0000\u0000\u06ac"+ + "\u06ad\u0007\u000f\u0000\u0000\u06ad\u06ae\u0007\n\u0000\u0000\u06aev"+ + "\u0001\u0000\u0000\u0000\u06af\u06b0\u0007\u000e\u0000\u0000\u06b0\u06b1"+ + "\u0007\u0016\u0000\u0000\u06b1\u06b2\u0007\r\u0000\u0000\u06b2\u06b3\u0007"+ + "\r\u0000\u0000\u06b3\u06b4\u0007\n\u0000\u0000\u06b4\u06b5\u0007\u0007"+ + "\u0000\u0000\u06b5\u06b6\u0007\u0010\u0000\u0000\u06b6\u06b7\u0005_\u0000"+ + "\u0000\u06b7\u06b8\u0007\u0010\u0000\u0000\u06b8\u06b9\u0007\u0011\u0000"+ + "\u0000\u06b9\u06ba\u0007\u000f\u0000\u0000\u06ba\u06bb\u0007\n\u0000\u0000"+ + "\u06bb\u06bc\u0007\t\u0000\u0000\u06bc\u06bd\u0007\u0010\u0000\u0000\u06bd"+ + "\u06be\u0007\u0005\u0000\u0000\u06be\u06bf\u0007\u000f\u0000\u0000\u06bf"+ + "\u06c0\u0007\u0018\u0000\u0000\u06c0x\u0001\u0000\u0000\u0000\u06c1\u06c2"+ + "\u0007\u000e\u0000\u0000\u06c2\u06c3\u0007\u0016\u0000\u0000\u06c3\u06c4"+ + "\u0007\r\u0000\u0000\u06c4\u06c5\u0007\r\u0000\u0000\u06c5\u06c6\u0007"+ + "\n\u0000\u0000\u06c6\u06c7\u0007\u0007\u0000\u0000\u06c7\u06c8\u0007\u0010"+ + "\u0000\u0000\u06c8\u06c9\u0005_\u0000\u0000\u06c9\u06ca\u0007\u0016\u0000"+ + "\u0000\u06ca\u06cb\u0007\t\u0000\u0000\u06cb\u06cc\u0007\n\u0000\u0000"+ + "\u06cc\u06cd\u0007\r\u0000\u0000\u06cdz\u0001\u0000\u0000\u0000\u06ce"+ + "\u06cf\u0007\f\u0000\u0000\u06cf\u06d0\u0007\n\u0000\u0000\u06d0\u06d1"+ + "\u0007\u0019\u0000\u0000\u06d1\u06d2\u0007\u0005\u0000\u0000\u06d2\u06d3"+ + "\u0007\u0016\u0000\u0000\u06d3\u06d4\u0007\u0006\u0000\u0000\u06d4\u06d5"+ + "\u0007\u0010\u0000\u0000\u06d5|\u0001\u0000\u0000\u0000\u06d6\u06d7\u0007"+ + "\f\u0000\u0000\u06d7\u06d8\u0007\n\u0000\u0000\u06d8\u06d9\u0007\u0019"+ + "\u0000\u0000\u06d9\u06da\u0007\n\u0000\u0000\u06da\u06db\u0007\r\u0000"+ + "\u0000\u06db\u06dc\u0007\r\u0000\u0000\u06dc\u06dd\u0007\u0005\u0000\u0000"+ + "\u06dd\u06de\u0007\u0012\u0000\u0000\u06de\u06df\u0007\u0006\u0000\u0000"+ + "\u06df\u06e0\u0007\n\u0000\u0000\u06e0~\u0001\u0000\u0000\u0000\u06e1"+ + "\u06e2\u0007\f\u0000\u0000\u06e2\u06e3\u0007\n\u0000\u0000\u06e3\u06e4"+ + "\u0007\t\u0000\u0000\u06e4\u06e5\u0007\u000e\u0000\u0000\u06e5\u0080\u0001"+ + "\u0000\u0000\u0000\u06e6\u06e7\u0007\f\u0000\u0000\u06e7\u06e8\u0007\u0011"+ + "\u0000\u0000\u06e8\u06e9\u0007\t\u0000\u0000\u06e9\u06ea\u0007\u0010\u0000"+ + "\u0000\u06ea\u06eb\u0007\u0011\u0000\u0000\u06eb\u06ec\u0007\u0007\u0000"+ + "\u0000\u06ec\u06ed\u0007\u000e\u0000\u0000\u06ed\u06ee\u0007\u0010\u0000"+ + "\u0000\u06ee\u0082\u0001\u0000\u0000\u0000\u06ef\u06f0\u0007\f\u0000\u0000"+ + "\u06f0\u06f1\u0007\u0013\u0000\u0000\u06f1\u0084\u0001\u0000\u0000\u0000"+ + "\u06f2\u06f3\u0007\n\u0000\u0000\u06f3\u06f4\u0007\u0006\u0000\u0000\u06f4"+ + "\u06f5\u0007\t\u0000\u0000\u06f5\u06f6\u0007\n\u0000\u0000\u06f6\u0086"+ + "\u0001\u0000\u0000\u0000\u06f7\u06f8\u0007\n\u0000\u0000\u06f8\u06f9\u0007"+ + "\u001a\u0000\u0000\u06f9\u06fa\u0007\u000e\u0000\u0000\u06fa\u06fb\u0007"+ + "\n\u0000\u0000\u06fb\u06fc\u0007\u0018\u0000\u0000\u06fc\u06fd\u0007\u0010"+ + "\u0000\u0000\u06fd\u0088\u0001\u0000\u0000\u0000\u06fe\u06ff\u0007\u0019"+ + "\u0000\u0000\u06ff\u0700\u0007\u0005\u0000\u0000\u0700\u0701\u0007\u0006"+ + "\u0000\u0000\u0701\u0702\u0007\t\u0000\u0000\u0702\u0703\u0007\n\u0000"+ + "\u0000\u0703\u008a\u0001\u0000\u0000\u0000\u0704\u0705\u0007\u0019\u0000"+ + "\u0000\u0705\u0706\u0007\n\u0000\u0000\u0706\u0707\u0007\u0010\u0000\u0000"+ + "\u0707\u0708\u0007\u000e\u0000\u0000\u0708\u0709\u0007\u0014\u0000\u0000"+ + "\u0709\u008c\u0001\u0000\u0000\u0000\u070a\u070b\u0007\u0019\u0000\u0000"+ + "\u070b\u070c\u0007\u0013\u0000\u0000\u070c\u070d\u0007\r\u0000\u0000\u070d"+ + "\u008e\u0001\u0000\u0000\u0000\u070e\u070f\u0007\u0019\u0000\u0000\u070f"+ + "\u0710\u0007\u0013\u0000\u0000\u0710\u0711\u0007\r\u0000\u0000\u0711\u0712"+ + "\u0007\n\u0000\u0000\u0712\u0713\u0007\u0011\u0000\u0000\u0713\u0714\u0007"+ + "\u0017\u0000\u0000\u0714\u0715\u0007\u0007\u0000\u0000\u0715\u0090\u0001"+ + "\u0000\u0000\u0000\u0716\u0717\u0007\u0019\u0000\u0000\u0717\u0718\u0007"+ + "\r\u0000\u0000\u0718\u0719\u0007\u0013\u0000\u0000\u0719\u071a\u0007\u000f"+ + "\u0000\u0000\u071a\u0092\u0001\u0000\u0000\u0000\u071b\u071c\u0007\u0017"+ + "\u0000\u0000\u071c\u071d\u0007\r\u0000\u0000\u071d\u071e\u0007\u0005\u0000"+ + "\u0000\u071e\u071f\u0007\u0007\u0000\u0000\u071f\u0720\u0007\u0010\u0000"+ + "\u0000\u0720\u0094\u0001\u0000\u0000\u0000\u0721\u0722\u0007\u0017\u0000"+ + "\u0000\u0722\u0723\u0007\r\u0000\u0000\u0723\u0724\u0007\u0013\u0000\u0000"+ + "\u0724\u0725\u0007\u0016\u0000\u0000\u0725\u0726\u0007\u0018\u0000\u0000"+ + "\u0726\u0096\u0001\u0000\u0000\u0000\u0727\u0728\u0007\u0014\u0000\u0000"+ + "\u0728\u0729\u0007\u0005\u0000\u0000\u0729\u072a\u0007\u001b\u0000\u0000"+ + "\u072a\u072b\u0007\u0011\u0000\u0000\u072b\u072c\u0007\u0007\u0000\u0000"+ + "\u072c\u072d\u0007\u0017\u0000\u0000\u072d\u0098\u0001\u0000\u0000\u0000"+ + "\u072e\u072f\u0007\u0011\u0000\u0000\u072f\u0730\u0007\u0007\u0000\u0000"+ + "\u0730\u009a\u0001\u0000\u0000\u0000\u0731\u0732\u0007\u0011\u0000\u0000"+ + "\u0732\u0733\u0007\u0007\u0000\u0000\u0733\u0734\u0007\u0011\u0000\u0000"+ + "\u0734\u0735\u0007\u0010\u0000\u0000\u0735\u0736\u0007\u0011\u0000\u0000"+ + "\u0736\u0737\u0007\u0005\u0000\u0000\u0737\u0738\u0007\u0006\u0000\u0000"+ + "\u0738\u0739\u0007\u0006\u0000\u0000\u0739\u073a\u0007\b\u0000\u0000\u073a"+ + "\u009c\u0001\u0000\u0000\u0000\u073b\u073c\u0007\u0011\u0000\u0000\u073c"+ + "\u073d\u0007\u0007\u0000\u0000\u073d\u073e\u0007\u0010\u0000\u0000\u073e"+ + "\u073f\u0007\n\u0000\u0000\u073f\u0740\u0007\r\u0000\u0000\u0740\u0741"+ + "\u0007\t\u0000\u0000\u0741\u0742\u0007\n\u0000\u0000\u0742\u0743\u0007"+ + "\u000e\u0000\u0000\u0743\u0744\u0007\u0010\u0000\u0000\u0744\u009e\u0001"+ + "\u0000\u0000\u0000\u0745\u0746\u0007\u0011\u0000\u0000\u0746\u0747\u0007"+ + "\u0007\u0000\u0000\u0747\u0748\u0007\u0010\u0000\u0000\u0748\u0749\u0007"+ + "\u0013\u0000\u0000\u0749\u00a0\u0001\u0000\u0000\u0000\u074a\u074b\u0007"+ + "\u0006\u0000\u0000\u074b\u074c\u0007\u0005\u0000\u0000\u074c\u074d\u0007"+ + "\u0010\u0000\u0000\u074d\u074e\u0007\n\u0000\u0000\u074e\u074f\u0007\r"+ + "\u0000\u0000\u074f\u0750\u0007\u0005\u0000\u0000\u0750\u0751\u0007\u0006"+ + "\u0000\u0000\u0751\u00a2\u0001\u0000\u0000\u0000\u0752\u0753\u0007\u0006"+ + "\u0000\u0000\u0753\u0754\u0007\n\u0000\u0000\u0754\u0755\u0007\u0005\u0000"+ + "\u0000\u0755\u0756\u0007\f\u0000\u0000\u0756\u0757\u0007\u0011\u0000\u0000"+ + "\u0757\u0758\u0007\u0007\u0000\u0000\u0758\u0759\u0007\u0017\u0000\u0000"+ + "\u0759\u00a4\u0001\u0000\u0000\u0000\u075a\u075b\u0007\u0006\u0000\u0000"+ + "\u075b\u075c\u0007\u0011\u0000\u0000\u075c\u075d\u0007\u000f\u0000\u0000"+ + "\u075d\u075e\u0007\u0011\u0000\u0000\u075e\u075f\u0007\u0010\u0000\u0000"+ + "\u075f\u00a6\u0001\u0000\u0000\u0000\u0760\u0761\u0007\u0006\u0000\u0000"+ + "\u0761\u0762\u0007\u0013\u0000\u0000\u0762\u0763\u0007\u000e\u0000\u0000"+ + "\u0763\u0764\u0007\u0005\u0000\u0000\u0764\u0765\u0007\u0006\u0000\u0000"+ + "\u0765\u0766\u0007\u0010\u0000\u0000\u0766\u0767\u0007\u0011\u0000\u0000"+ + "\u0767\u0768\u0007\u000f\u0000\u0000\u0768\u0769\u0007\n\u0000\u0000\u0769"+ + "\u00a8\u0001\u0000\u0000\u0000\u076a\u076b\u0007\u0006\u0000\u0000\u076b"+ + "\u076c\u0007\u0013\u0000\u0000\u076c\u076d\u0007\u000e\u0000\u0000\u076d"+ + "\u076e\u0007\u0005\u0000\u0000\u076e\u076f\u0007\u0006\u0000\u0000\u076f"+ + "\u0770\u0007\u0010\u0000\u0000\u0770\u0771\u0007\u0011\u0000\u0000\u0771"+ + "\u0772\u0007\u000f\u0000\u0000\u0772\u0773\u0007\n\u0000\u0000\u0773\u0774"+ + "\u0007\t\u0000\u0000\u0774\u0775\u0007\u0010\u0000\u0000\u0775\u0776\u0007"+ + "\u0005\u0000\u0000\u0776\u0777\u0007\u000f\u0000\u0000\u0777\u0778\u0007"+ + "\u0018\u0000\u0000\u0778\u00aa\u0001\u0000\u0000\u0000\u0779\u077a\u0007"+ + "\u0007\u0000\u0000\u077a\u077b\u0007\u0013\u0000\u0000\u077b\u077c\u0007"+ + "\u0010\u0000\u0000\u077c\u00ac\u0001\u0000\u0000\u0000\u077d\u077e\u0007"+ + "\u0007\u0000\u0000\u077e\u077f\u0007\u0016\u0000\u0000\u077f\u0780\u0007"+ + "\u0006\u0000\u0000\u0780\u0781\u0007\u0006\u0000\u0000\u0781\u00ae\u0001"+ + "\u0000\u0000\u0000\u0782\u0783\u0007\u0013\u0000\u0000\u0783\u0784\u0007"+ + "\u0019\u0000\u0000\u0784\u0785\u0007\u0019\u0000\u0000\u0785\u0786\u0007"+ + "\t\u0000\u0000\u0786\u0787\u0007\n\u0000\u0000\u0787\u0788\u0007\u0010"+ + "\u0000\u0000\u0788\u00b0\u0001\u0000\u0000\u0000\u0789\u078a\u0007\u0013"+ + "\u0000\u0000\u078a\u078b\u0007\u0007\u0000\u0000\u078b\u00b2\u0001\u0000"+ + "\u0000\u0000\u078c\u078d\u0007\u0013\u0000\u0000\u078d\u078e\u0007\u0007"+ + "\u0000\u0000\u078e\u078f\u0007\u0006\u0000\u0000\u078f\u0790\u0007\b\u0000"+ + "\u0000\u0790\u00b4\u0001\u0000\u0000\u0000\u0791\u0792\u0007\u0013\u0000"+ + "\u0000\u0792\u0793\u0007\r\u0000\u0000\u0793\u00b6\u0001\u0000\u0000\u0000"+ + "\u0794\u0795\u0007\u0013\u0000\u0000\u0795\u0796\u0007\r\u0000\u0000\u0796"+ + "\u0797\u0007\f\u0000\u0000\u0797\u0798\u0007\n\u0000\u0000\u0798\u0799"+ + "\u0007\r\u0000\u0000\u0799\u00b8\u0001\u0000\u0000\u0000\u079a\u079b\u0007"+ + "\u0018\u0000\u0000\u079b\u079c\u0007\u0006\u0000\u0000\u079c\u079d\u0007"+ + "\u0005\u0000\u0000\u079d\u079e\u0007\u000e\u0000\u0000\u079e\u079f\u0007"+ + "\u0011\u0000\u0000\u079f\u07a0\u0007\u0007\u0000\u0000\u07a0\u07a1\u0007"+ + "\u0017\u0000\u0000\u07a1\u00ba\u0001\u0000\u0000\u0000\u07a2\u07a3\u0007"+ + "\u0018\u0000\u0000\u07a3\u07a4\u0007\r\u0000\u0000\u07a4\u07a5\u0007\u0011"+ + "\u0000\u0000\u07a5\u07a6\u0007\u000f\u0000\u0000\u07a6\u07a7\u0007\u0005"+ + "\u0000\u0000\u07a7\u07a8\u0007\r\u0000\u0000\u07a8\u07a9\u0007\b\u0000"+ + "\u0000\u07a9\u00bc\u0001\u0000\u0000\u0000\u07aa\u07ab\u0007\r\u0000\u0000"+ + "\u07ab\u07ac\u0007\n\u0000\u0000\u07ac\u07ad\u0007\u0019\u0000\u0000\u07ad"+ + "\u07ae\u0007\n\u0000\u0000\u07ae\u07af\u0007\r\u0000\u0000\u07af\u07b0"+ + "\u0007\n\u0000\u0000\u07b0\u07b1\u0007\u0007\u0000\u0000\u07b1\u07b2\u0007"+ + "\u000e\u0000\u0000\u07b2\u07b3\u0007\n\u0000\u0000\u07b3\u07b4\u0007\t"+ + "\u0000\u0000\u07b4\u00be\u0001\u0000\u0000\u0000\u07b5\u07b6\u0007\r\u0000"+ + "\u0000\u07b6\u07b7\u0007\n\u0000\u0000\u07b7\u07b8\u0007\u0010\u0000\u0000"+ + "\u07b8\u07b9\u0007\u0016\u0000\u0000\u07b9\u07ba\u0007\r\u0000\u0000\u07ba"+ + "\u07bb\u0007\u0007\u0000\u0000\u07bb\u07bc\u0007\u0011\u0000\u0000\u07bc"+ + "\u07bd\u0007\u0007\u0000\u0000\u07bd\u07be\u0007\u0017\u0000\u0000\u07be"+ + "\u00c0\u0001\u0000\u0000\u0000\u07bf\u07c0\u0007\t\u0000\u0000\u07c0\u07c1"+ + "\u0007\n\u0000\u0000\u07c1\u07c2\u0007\u0006\u0000\u0000\u07c2\u07c3\u0007"+ + "\n\u0000\u0000\u07c3\u07c4\u0007\u000e\u0000\u0000\u07c4\u07c5\u0007\u0010"+ + "\u0000\u0000\u07c5\u00c2\u0001\u0000\u0000\u0000\u07c6\u07c7\u0007\t\u0000"+ + "\u0000\u07c7\u07c8\u0007\n\u0000\u0000\u07c8\u07c9\u0007\t\u0000\u0000"+ + "\u07c9\u07ca\u0007\t\u0000\u0000\u07ca\u07cb\u0007\u0011\u0000\u0000\u07cb"+ + "\u07cc\u0007\u0013\u0000\u0000\u07cc\u07cd\u0007\u0007\u0000\u0000\u07cd"+ + "\u07ce\u0005_\u0000\u0000\u07ce\u07cf\u0007\u0016\u0000\u0000\u07cf\u07d0"+ + "\u0007\t\u0000\u0000\u07d0\u07d1\u0007\n\u0000\u0000\u07d1\u07d2\u0007"+ + "\r\u0000\u0000\u07d2\u00c4\u0001\u0000\u0000\u0000\u07d3\u07d4\u0007\t"+ + "\u0000\u0000\u07d4\u07d5\u0007\u0013\u0000\u0000\u07d5\u07d6\u0007\u000f"+ + "\u0000\u0000\u07d6\u07d7\u0007\n\u0000\u0000\u07d7\u00c6\u0001\u0000\u0000"+ + "\u0000\u07d8\u07d9\u0007\t\u0000\u0000\u07d9\u07da\u0007\b\u0000\u0000"+ + "\u07da\u07db\u0007\u000f\u0000\u0000\u07db\u07dc\u0007\u000f\u0000\u0000"+ + "\u07dc\u07dd\u0007\n\u0000\u0000\u07dd\u07de\u0007\u0010\u0000\u0000\u07de"+ + "\u07df\u0007\r\u0000\u0000\u07df\u07e0\u0007\u0011\u0000\u0000\u07e0\u07e1"+ + "\u0007\u000e\u0000\u0000\u07e1\u00c8\u0001\u0000\u0000\u0000\u07e2\u07e3"+ + "\u0007\u0010\u0000\u0000\u07e3\u07e4\u0007\u0005\u0000\u0000\u07e4\u07e5"+ + "\u0007\u0012\u0000\u0000\u07e5\u07e6\u0007\u0006\u0000\u0000\u07e6\u07e7"+ + "\u0007\n\u0000\u0000\u07e7\u00ca\u0001\u0000\u0000\u0000\u07e8\u07e9\u0007"+ + "\u0010\u0000\u0000\u07e9\u07ea\u0007\u0014\u0000\u0000\u07ea\u07eb\u0007"+ + "\n\u0000\u0000\u07eb\u07ec\u0007\u0007\u0000\u0000\u07ec\u00cc\u0001\u0000"+ + "\u0000\u0000\u07ed\u07ee\u0007\u0010\u0000\u0000\u07ee\u07ef\u0007\u0013"+ + "\u0000\u0000\u07ef\u00ce\u0001\u0000\u0000\u0000\u07f0\u07f1\u0007\u0010"+ + "\u0000\u0000\u07f1\u07f2\u0007\r\u0000\u0000\u07f2\u07f3\u0007\u0005\u0000"+ + "\u0000\u07f3\u07f4\u0007\u0011\u0000\u0000\u07f4\u07f5\u0007\u0006\u0000"+ + "\u0000\u07f5\u07f6\u0007\u0011\u0000\u0000\u07f6\u07f7\u0007\u0007\u0000"+ + "\u0000\u07f7\u07f8\u0007\u0017\u0000\u0000\u07f8\u00d0\u0001\u0000\u0000"+ + "\u0000\u07f9\u07fa\u0007\u0010\u0000\u0000\u07fa\u07fb\u0007\r\u0000\u0000"+ + "\u07fb\u07fc\u0007\u0016\u0000\u0000\u07fc\u07fd\u0007\n\u0000\u0000\u07fd"+ + "\u00d2\u0001\u0000\u0000\u0000\u07fe\u07ff\u0007\u0016\u0000\u0000\u07ff"+ + "\u0800\u0007\u0007\u0000\u0000\u0800\u0801\u0007\u0011\u0000\u0000\u0801"+ + "\u0802\u0007\u0013\u0000\u0000\u0802\u0803\u0007\u0007\u0000\u0000\u0803"+ + "\u00d4\u0001\u0000\u0000\u0000\u0804\u0805\u0007\u0016\u0000\u0000\u0805"+ + "\u0806\u0007\u0007\u0000\u0000\u0806\u0807\u0007\u0011\u0000\u0000\u0807"+ + "\u0808\u0007\u001c\u0000\u0000\u0808\u0809\u0007\u0016\u0000\u0000\u0809"+ + "\u080a\u0007\n\u0000\u0000\u080a\u00d6\u0001\u0000\u0000\u0000\u080b\u080c"+ + "\u0007\u0016\u0000\u0000\u080c\u080d\u0007\t\u0000\u0000\u080d\u080e\u0007"+ + "\n\u0000\u0000\u080e\u080f\u0007\r\u0000\u0000\u080f\u00d8\u0001\u0000"+ + "\u0000\u0000\u0810\u0811\u0007\u0016\u0000\u0000\u0811\u0812\u0007\t\u0000"+ + "\u0000\u0812\u0813\u0007\u0011\u0000\u0000\u0813\u0814\u0007\u0007\u0000"+ + "\u0000\u0814\u0815\u0007\u0017\u0000\u0000\u0815\u00da\u0001\u0000\u0000"+ + "\u0000\u0816\u0817\u0007\u001b\u0000\u0000\u0817\u0818\u0007\u0005\u0000"+ + "\u0000\u0818\u0819\u0007\r\u0000\u0000\u0819\u081a\u0007\u0011\u0000\u0000"+ + "\u081a\u081b\u0007\u0005\u0000\u0000\u081b\u081c\u0007\f\u0000\u0000\u081c"+ + "\u081d\u0007\u0011\u0000\u0000\u081d\u081e\u0007\u000e\u0000\u0000\u081e"+ + "\u00dc\u0001\u0000\u0000\u0000\u081f\u0820\u0007\u001d\u0000\u0000\u0820"+ + "\u0821\u0007\u0014\u0000\u0000\u0821\u0822\u0007\n\u0000\u0000\u0822\u0823"+ + "\u0007\u0007\u0000\u0000\u0823\u00de\u0001\u0000\u0000\u0000\u0824\u0825"+ + "\u0007\u001d\u0000\u0000\u0825\u0826\u0007\u0014\u0000\u0000\u0826\u0827"+ + "\u0007\n\u0000\u0000\u0827\u0828\u0007\r\u0000\u0000\u0828\u0829\u0007"+ + "\n\u0000\u0000\u0829\u00e0\u0001\u0000\u0000\u0000\u082a\u082b\u0007\u001d"+ + "\u0000\u0000\u082b\u082c\u0007\u0011\u0000\u0000\u082c\u082d\u0007\u0007"+ + "\u0000\u0000\u082d\u082e\u0007\f\u0000\u0000\u082e\u082f\u0007\u0013\u0000"+ + "\u0000\u082f\u0830\u0007\u001d\u0000\u0000\u0830\u00e2\u0001\u0000\u0000"+ + "\u0000\u0831\u0832\u0007\u001d\u0000\u0000\u0832\u0833\u0007\u0011\u0000"+ + "\u0000\u0833\u0834\u0007\u0010\u0000\u0000\u0834\u0835\u0007\u0014\u0000"+ + "\u0000\u0835\u00e4\u0001\u0000\u0000\u0000\u0836\u0837\u0007\u0005\u0000"+ + "\u0000\u0837\u0838\u0007\u0016\u0000\u0000\u0838\u0839\u0007\u0010\u0000"+ + "\u0000\u0839\u083a\u0007\u0014\u0000\u0000\u083a\u083b\u0007\u0013\u0000"+ + "\u0000\u083b\u083c\u0007\r\u0000\u0000\u083c\u083d\u0007\u0011\u0000\u0000"+ + "\u083d\u083e\u0007\u000b\u0000\u0000\u083e\u083f\u0007\u0005\u0000\u0000"+ + "\u083f\u0840\u0007\u0010\u0000\u0000\u0840\u0841\u0007\u0011\u0000\u0000"+ + "\u0841\u0842\u0007\u0013\u0000\u0000\u0842\u0843\u0007\u0007\u0000\u0000"+ + "\u0843\u00e6\u0001\u0000\u0000\u0000\u0844\u0845\u0007\u0012\u0000\u0000"+ + "\u0845\u0846\u0007\u0011\u0000\u0000\u0846\u0847\u0007\u0007\u0000\u0000"+ + "\u0847\u0848\u0007\u0005\u0000\u0000\u0848\u0849\u0007\r\u0000\u0000\u0849"+ + "\u084a\u0007\b\u0000\u0000\u084a\u00e8\u0001\u0000\u0000\u0000\u084b\u084c"+ + "\u0007\u000e\u0000\u0000\u084c\u084d\u0007\u0013\u0000\u0000\u084d\u084e"+ + "\u0007\u0006\u0000\u0000\u084e\u084f\u0007\u0006\u0000\u0000\u084f\u0850"+ + "\u0007\u0005\u0000\u0000\u0850\u0851\u0007\u0010\u0000\u0000\u0851\u0852"+ + "\u0007\u0011\u0000\u0000\u0852\u0853\u0007\u0013\u0000\u0000\u0853\u0854"+ + "\u0007\u0007\u0000\u0000\u0854\u00ea\u0001\u0000\u0000\u0000\u0855\u0856"+ + "\u0007\u000e\u0000\u0000\u0856\u0857\u0007\u0013\u0000\u0000\u0857\u0858"+ + "\u0007\u0007\u0000\u0000\u0858\u0859\u0007\u000e\u0000\u0000\u0859\u085a"+ + "\u0007\u0016\u0000\u0000\u085a\u085b\u0007\r\u0000\u0000\u085b\u085c\u0007"+ + "\r\u0000\u0000\u085c\u085d\u0007\n\u0000\u0000\u085d\u085e\u0007\u0007"+ + "\u0000\u0000\u085e\u085f\u0007\u0010\u0000\u0000\u085f\u0860\u0007\u0006"+ + "\u0000\u0000\u0860\u0861\u0007\b\u0000\u0000\u0861\u00ec\u0001\u0000\u0000"+ + "\u0000\u0862\u0863\u0007\u000e\u0000\u0000\u0863\u0864\u0007\r\u0000\u0000"+ + "\u0864\u0865\u0007\u0013\u0000\u0000\u0865\u0866\u0007\t\u0000\u0000\u0866"+ + "\u0867\u0007\t\u0000\u0000\u0867\u00ee\u0001\u0000\u0000\u0000\u0868\u0869"+ + "\u0007\u000e\u0000\u0000\u0869\u086a\u0007\u0016\u0000\u0000\u086a\u086b"+ + "\u0007\r\u0000\u0000\u086b\u086c\u0007\r\u0000\u0000\u086c\u086d\u0007"+ + "\n\u0000\u0000\u086d\u086e\u0007\u0007\u0000\u0000\u086e\u086f\u0007\u0010"+ + "\u0000\u0000\u086f\u0870\u0005_\u0000\u0000\u0870\u0871\u0007\t\u0000"+ + "\u0000\u0871\u0872\u0007\u000e\u0000\u0000\u0872\u0873\u0007\u0014\u0000"+ + "\u0000\u0873\u0874\u0007\n\u0000\u0000\u0874\u0875\u0007\u000f\u0000\u0000"+ + "\u0875\u0876\u0007\u0005\u0000\u0000\u0876\u00f0\u0001\u0000\u0000\u0000"+ + "\u0877\u0878\u0007\u0019\u0000\u0000\u0878\u0879\u0007\r\u0000\u0000\u0879"+ + "\u087a\u0007\n\u0000\u0000\u087a\u087b\u0007\n\u0000\u0000\u087b\u087c"+ + "\u0007\u000b\u0000\u0000\u087c\u087d\u0007\n\u0000\u0000\u087d\u00f2\u0001"+ + "\u0000\u0000\u0000\u087e\u087f\u0007\u0019\u0000\u0000\u087f\u0880\u0007"+ + "\u0016\u0000\u0000\u0880\u0881\u0007\u0006\u0000\u0000\u0881\u0882\u0007"+ + "\u0006\u0000\u0000\u0882\u00f4\u0001\u0000\u0000\u0000\u0883\u0884\u0007"+ + "\u0011\u0000\u0000\u0884\u0885\u0007\u0006\u0000\u0000\u0885\u0886\u0007"+ + "\u0011\u0000\u0000\u0886\u0887\u0007\u0015\u0000\u0000\u0887\u0888\u0007"+ + "\n\u0000\u0000\u0888\u00f6\u0001\u0000\u0000\u0000\u0889\u088a\u0007\u0011"+ + "\u0000\u0000\u088a\u088b\u0007\u0007\u0000\u0000\u088b\u088c\u0007\u0007"+ + "\u0000\u0000\u088c\u088d\u0007\n\u0000\u0000\u088d\u088e\u0007\r\u0000"+ + "\u0000\u088e\u00f8\u0001\u0000\u0000\u0000\u088f\u0890\u0007\u0011\u0000"+ + "\u0000\u0890\u0891\u0007\t\u0000\u0000\u0891\u00fa\u0001\u0000\u0000\u0000"+ + "\u0892\u0893\u0007\u0011\u0000\u0000\u0893\u0894\u0007\t\u0000\u0000\u0894"+ + "\u0895\u0007\u0007\u0000\u0000\u0895\u0896\u0007\u0016\u0000\u0000\u0896"+ + "\u0897\u0007\u0006\u0000\u0000\u0897\u0898\u0007\u0006\u0000\u0000\u0898"+ + "\u00fc\u0001\u0000\u0000\u0000\u0899\u089a\u0007\u001e\u0000\u0000\u089a"+ + "\u089b\u0007\u0013\u0000\u0000\u089b\u089c\u0007\u0011\u0000\u0000\u089c"+ + "\u089d\u0007\u0007\u0000\u0000\u089d\u00fe\u0001\u0000\u0000\u0000\u089e"+ + "\u089f\u0007\u0006\u0000\u0000\u089f\u08a0\u0007\n\u0000\u0000\u08a0\u08a1"+ + "\u0007\u0019\u0000\u0000\u08a1\u08a2\u0007\u0010\u0000\u0000\u08a2\u0100"+ + "\u0001\u0000\u0000\u0000\u08a3\u08a4\u0007\u0006\u0000\u0000\u08a4\u08a5"+ + "\u0007\u0011\u0000\u0000\u08a5\u08a6\u0007\u0015\u0000\u0000\u08a6\u08a7"+ + "\u0007\n\u0000\u0000\u08a7\u0102\u0001\u0000\u0000\u0000\u08a8\u08a9\u0007"+ + "\u0007\u0000\u0000\u08a9\u08aa\u0007\u0005\u0000\u0000\u08aa\u08ab\u0007"+ + "\u0010\u0000\u0000\u08ab\u08ac\u0007\u0016\u0000\u0000\u08ac\u08ad\u0007"+ + "\r\u0000\u0000\u08ad\u08ae\u0007\u0005\u0000\u0000\u08ae\u08af\u0007\u0006"+ + "\u0000\u0000\u08af\u0104\u0001\u0000\u0000\u0000\u08b0\u08b1\u0007\u0007"+ + "\u0000\u0000\u08b1\u08b2\u0007\u0013\u0000\u0000\u08b2\u08b3\u0007\u0010"+ + "\u0000\u0000\u08b3\u08b4\u0007\u0007\u0000\u0000\u08b4\u08b5\u0007\u0016"+ + "\u0000\u0000\u08b5\u08b6\u0007\u0006\u0000\u0000\u08b6\u08b7\u0007\u0006"+ + "\u0000\u0000\u08b7\u0106\u0001\u0000\u0000\u0000\u08b8\u08b9\u0007\u0013"+ + "\u0000\u0000\u08b9\u08ba\u0007\u0016\u0000\u0000\u08ba\u08bb\u0007\u0010"+ + "\u0000\u0000\u08bb\u08bc\u0007\n\u0000\u0000\u08bc\u08bd\u0007\r\u0000"+ + "\u0000\u08bd\u0108\u0001\u0000\u0000\u0000\u08be\u08bf\u0007\u0013\u0000"+ + "\u0000\u08bf\u08c0\u0007\u001b\u0000\u0000\u08c0\u08c1\u0007\n\u0000\u0000"+ + "\u08c1\u08c2\u0007\r\u0000\u0000\u08c2\u010a\u0001\u0000\u0000\u0000\u08c3"+ + "\u08c4\u0007\u0013\u0000\u0000\u08c4\u08c5\u0007\u001b\u0000\u0000\u08c5"+ + "\u08c6\u0007\n\u0000\u0000\u08c6\u08c7\u0007\r\u0000\u0000\u08c7\u08c8"+ + "\u0007\u0006\u0000\u0000\u08c8\u08c9\u0007\u0005\u0000\u0000\u08c9\u08ca"+ + "\u0007\u0018\u0000\u0000\u08ca\u08cb\u0007\t\u0000\u0000\u08cb\u010c\u0001"+ + "\u0000\u0000\u0000\u08cc\u08cd\u0007\r\u0000\u0000\u08cd\u08ce\u0007\u0011"+ + "\u0000\u0000\u08ce\u08cf\u0007\u0017\u0000\u0000\u08cf\u08d0\u0007\u0014"+ + "\u0000\u0000\u08d0\u08d1\u0007\u0010\u0000\u0000\u08d1\u010e\u0001\u0000"+ + "\u0000\u0000\u08d2\u08d3\u0007\t\u0000\u0000\u08d3\u08d4\u0007\u0011\u0000"+ + "\u0000\u08d4\u08d5\u0007\u000f\u0000\u0000\u08d5\u08d6\u0007\u0011\u0000"+ + "\u0000\u08d6\u08d7\u0007\u0006\u0000\u0000\u08d7\u08d8\u0007\u0005\u0000"+ + "\u0000\u08d8\u08d9\u0007\r\u0000\u0000\u08d9\u0110\u0001\u0000\u0000\u0000"+ + "\u08da\u08db\u0007\u001b\u0000\u0000\u08db\u08dc\u0007\n\u0000\u0000\u08dc"+ + "\u08dd\u0007\r\u0000\u0000\u08dd\u08de\u0007\u0012\u0000\u0000\u08de\u08df"+ + "\u0007\u0013\u0000\u0000\u08df\u08e0\u0007\t\u0000\u0000\u08e0\u08e1\u0007"+ + "\n\u0000\u0000\u08e1\u0112\u0001\u0000\u0000\u0000\u08e2\u08e3\u0007\u0005"+ + "\u0000\u0000\u08e3\u08e4\u0007\u0012\u0000\u0000\u08e4\u08e5\u0007\u0013"+ + "\u0000\u0000\u08e5\u08e6\u0007\r\u0000\u0000\u08e6\u08e7\u0007\u0010\u0000"+ + "\u0000\u08e7\u0114\u0001\u0000\u0000\u0000\u08e8\u08e9\u0007\u0005\u0000"+ + "\u0000\u08e9\u08ea\u0007\u0012\u0000\u0000\u08ea\u08eb\u0007\t\u0000\u0000"+ + "\u08eb\u08ec\u0007\u0013\u0000\u0000\u08ec\u08ed\u0007\u0006\u0000\u0000"+ + "\u08ed\u08ee\u0007\u0016\u0000\u0000\u08ee\u08ef\u0007\u0010\u0000\u0000"+ + "\u08ef\u08f0\u0007\n\u0000\u0000\u08f0\u0116\u0001\u0000\u0000\u0000\u08f1"+ + "\u08f2\u0007\u0005\u0000\u0000\u08f2\u08f3\u0007\u000e\u0000\u0000\u08f3"+ + "\u08f4\u0007\u000e\u0000\u0000\u08f4\u08f5\u0007\n\u0000\u0000\u08f5\u08f6"+ + "\u0007\t\u0000\u0000\u08f6\u08f7\u0007\t\u0000\u0000\u08f7\u0118\u0001"+ + "\u0000\u0000\u0000\u08f8\u08f9\u0007\u0005\u0000\u0000\u08f9\u08fa\u0007"+ + "\u000e\u0000\u0000\u08fa\u08fb\u0007\u0010\u0000\u0000\u08fb\u08fc\u0007"+ + "\u0011\u0000\u0000\u08fc\u08fd\u0007\u0013\u0000\u0000\u08fd\u08fe\u0007"+ + "\u0007\u0000\u0000\u08fe\u011a\u0001\u0000\u0000\u0000\u08ff\u0900\u0007"+ + "\u0005\u0000\u0000\u0900\u0901\u0007\f\u0000\u0000\u0901\u0902\u0007\f"+ + "\u0000\u0000\u0902\u011c\u0001\u0000\u0000\u0000\u0903\u0904\u0007\u0005"+ + "\u0000\u0000\u0904\u0905\u0007\f\u0000\u0000\u0905\u0906\u0007\u000f\u0000"+ + "\u0000\u0906\u0907\u0007\u0011\u0000\u0000\u0907\u0908\u0007\u0007\u0000"+ + "\u0000\u0908\u011e\u0001\u0000\u0000\u0000\u0909\u090a\u0007\u0005\u0000"+ + "\u0000\u090a\u090b\u0007\u0019\u0000\u0000\u090b\u090c\u0007\u0010\u0000"+ + "\u0000\u090c\u090d\u0007\n\u0000\u0000\u090d\u090e\u0007\r\u0000\u0000"+ + "\u090e\u0120\u0001\u0000\u0000\u0000\u090f\u0910\u0007\u0005\u0000\u0000"+ + "\u0910\u0911\u0007\u0017\u0000\u0000\u0911\u0912\u0007\u0017\u0000\u0000"+ + "\u0912\u0913\u0007\r\u0000\u0000\u0913\u0914\u0007\n\u0000\u0000\u0914"+ + "\u0915\u0007\u0017\u0000\u0000\u0915\u0916\u0007\u0005\u0000\u0000\u0916"+ + "\u0917\u0007\u0010\u0000\u0000\u0917\u0918\u0007\n\u0000\u0000\u0918\u0122"+ + "\u0001\u0000\u0000\u0000\u0919\u091a\u0007\u0005\u0000\u0000\u091a\u091b"+ + "\u0007\u0006\u0000\u0000\u091b\u091c\u0007\t\u0000\u0000\u091c\u091d\u0007"+ + "\u0013\u0000\u0000\u091d\u0124\u0001\u0000\u0000\u0000\u091e\u091f\u0007"+ + "\u0005\u0000\u0000\u091f\u0920\u0007\u0006\u0000\u0000\u0920\u0921\u0007"+ + "\u0010\u0000\u0000\u0921\u0922\u0007\n\u0000\u0000\u0922\u0923\u0007\r"+ + "\u0000\u0000\u0923\u0126\u0001\u0000\u0000\u0000\u0924\u0925\u0007\u0005"+ + "\u0000\u0000\u0925\u0926\u0007\u0006\u0000\u0000\u0926\u0927\u0007\u001d"+ + "\u0000\u0000\u0927\u0928\u0007\u0005\u0000\u0000\u0928\u0929\u0007\b\u0000"+ + "\u0000\u0929\u092a\u0007\t\u0000\u0000\u092a\u0128\u0001\u0000\u0000\u0000"+ + "\u092b\u092c\u0007\u0005\u0000\u0000\u092c\u092d\u0007\t\u0000\u0000\u092d"+ + "\u092e\u0007\t\u0000\u0000\u092e\u092f\u0007\n\u0000\u0000\u092f\u0930"+ + "\u0007\r\u0000\u0000\u0930\u0931\u0007\u0010\u0000\u0000\u0931\u0932\u0007"+ + "\u0011\u0000\u0000\u0932\u0933\u0007\u0013\u0000\u0000\u0933\u0934\u0007"+ + "\u0007\u0000\u0000\u0934\u012a\u0001\u0000\u0000\u0000\u0935\u0936\u0007"+ + "\u0005\u0000\u0000\u0936\u0937\u0007\t\u0000\u0000\u0937\u0938\u0007\t"+ + "\u0000\u0000\u0938\u0939\u0007\u0011\u0000\u0000\u0939\u093a\u0007\u0017"+ + "\u0000\u0000\u093a\u093b\u0007\u0007\u0000\u0000\u093b\u093c\u0007\u000f"+ + "\u0000\u0000\u093c\u093d\u0007\n\u0000\u0000\u093d\u093e\u0007\u0007\u0000"+ + "\u0000\u093e\u093f\u0007\u0010\u0000\u0000\u093f\u012c\u0001\u0000\u0000"+ + "\u0000\u0940\u0941\u0007\u0005\u0000\u0000\u0941\u0942\u0007\u0010\u0000"+ + "\u0000\u0942\u012e\u0001\u0000\u0000\u0000\u0943\u0944\u0007\u0005\u0000"+ + "\u0000\u0944\u0945\u0007\u0010\u0000\u0000\u0945\u0946\u0007\u0010\u0000"+ + "\u0000\u0946\u0947\u0007\r\u0000\u0000\u0947\u0948\u0007\u0011\u0000\u0000"+ + "\u0948\u0949\u0007\u0012\u0000\u0000\u0949\u094a\u0007\u0016\u0000\u0000"+ + "\u094a\u094b\u0007\u0010\u0000\u0000\u094b\u094c\u0007\n\u0000\u0000\u094c"+ + "\u0130\u0001\u0000\u0000\u0000\u094d\u094e\u0007\u0012\u0000\u0000\u094e"+ + "\u094f\u0007\u0005\u0000\u0000\u094f\u0950\u0007\u000e\u0000\u0000\u0950"+ + "\u0951\u0007\u0015\u0000\u0000\u0951\u0952\u0007\u001d\u0000\u0000\u0952"+ + "\u0953\u0007\u0005\u0000\u0000\u0953\u0954\u0007\r\u0000\u0000\u0954\u0955"+ + "\u0007\f\u0000\u0000\u0955\u0132\u0001\u0000\u0000\u0000\u0956\u0957\u0007"+ + "\u0012\u0000\u0000\u0957\u0958\u0007\n\u0000\u0000\u0958\u0959\u0007\u0019"+ + "\u0000\u0000\u0959\u095a\u0007\u0013\u0000\u0000\u095a\u095b\u0007\r\u0000"+ + "\u0000\u095b\u095c\u0007\n\u0000\u0000\u095c\u0134\u0001\u0000\u0000\u0000"+ + "\u095d\u095e\u0007\u0012\u0000\u0000\u095e\u095f\u0007\n\u0000\u0000\u095f"+ + "\u0960\u0007\u0017\u0000\u0000\u0960\u0961\u0007\u0011\u0000\u0000\u0961"+ + "\u0962\u0007\u0007\u0000\u0000\u0962\u0136\u0001\u0000\u0000\u0000\u0963"+ + "\u0964\u0007\u0012\u0000\u0000\u0964\u0965\u0007\b\u0000\u0000\u0965\u0138"+ + "\u0001\u0000\u0000\u0000\u0966\u0967\u0007\u000e\u0000\u0000\u0967\u0968"+ + "\u0007\u0005\u0000\u0000\u0968\u0969\u0007\u000e\u0000\u0000\u0969\u096a"+ + "\u0007\u0014\u0000\u0000\u096a\u096b\u0007\n\u0000\u0000\u096b\u013a\u0001"+ + "\u0000\u0000\u0000\u096c\u096d\u0007\u000e\u0000\u0000\u096d\u096e\u0007"+ + "\u0005\u0000\u0000\u096e\u096f\u0007\u0006\u0000\u0000\u096f\u0970\u0007"+ + "\u0006\u0000\u0000\u0970\u0971\u0007\n\u0000\u0000\u0971\u0972\u0007\f"+ + "\u0000\u0000\u0972\u013c\u0001\u0000\u0000\u0000\u0973\u0974\u0007\u000e"+ + "\u0000\u0000\u0974\u0975\u0007\u0005\u0000\u0000\u0975\u0976\u0007\t\u0000"+ + "\u0000\u0976\u0977\u0007\u000e\u0000\u0000\u0977\u0978\u0007\u0005\u0000"+ + "\u0000\u0978\u0979\u0007\f\u0000\u0000\u0979\u097a\u0007\n\u0000\u0000"+ + "\u097a\u013e\u0001\u0000\u0000\u0000\u097b\u097c\u0007\u000e\u0000\u0000"+ + "\u097c\u097d\u0007\u0005\u0000\u0000\u097d\u097e\u0007\t\u0000\u0000\u097e"+ + "\u097f\u0007\u000e\u0000\u0000\u097f\u0980\u0007\u0005\u0000\u0000\u0980"+ + "\u0981\u0007\f\u0000\u0000\u0981\u0982\u0007\n\u0000\u0000\u0982\u0983"+ + "\u0007\f\u0000\u0000\u0983\u0140\u0001\u0000\u0000\u0000\u0984\u0985\u0007"+ + "\u000e\u0000\u0000\u0985\u0986\u0007\u0005\u0000\u0000\u0986\u0987\u0007"+ + "\u0010\u0000\u0000\u0987\u0988\u0007\u0005\u0000\u0000\u0988\u0989\u0007"+ + "\u0006\u0000\u0000\u0989\u098a\u0007\u0013\u0000\u0000\u098a\u098b\u0007"+ + "\u0017\u0000\u0000\u098b\u0142\u0001\u0000\u0000\u0000\u098c\u098d\u0007"+ + "\u000e\u0000\u0000\u098d\u098e\u0007\u0014\u0000\u0000\u098e\u098f\u0007"+ + "\u0005\u0000\u0000\u098f\u0990\u0007\u0011\u0000\u0000\u0990\u0991\u0007"+ + "\u0007\u0000\u0000\u0991\u0144\u0001\u0000\u0000\u0000\u0992\u0993\u0007"+ + "\u000e\u0000\u0000\u0993\u0994\u0007\u0014\u0000\u0000\u0994\u0995\u0007"+ + "\u0005\u0000\u0000\u0995\u0996\u0007\r\u0000\u0000\u0996\u0997\u0007\u0005"+ + "\u0000\u0000\u0997\u0998\u0007\u000e\u0000\u0000\u0998\u0999\u0007\u0010"+ + "\u0000\u0000\u0999\u099a\u0007\n\u0000\u0000\u099a\u099b\u0007\r\u0000"+ + "\u0000\u099b\u099c\u0007\u0011\u0000\u0000\u099c\u099d\u0007\t\u0000\u0000"+ + "\u099d\u099e\u0007\u0010\u0000\u0000\u099e\u099f\u0007\u0011\u0000\u0000"+ + "\u099f\u09a0\u0007\u000e\u0000\u0000\u09a0\u09a1\u0007\t\u0000\u0000\u09a1"+ + "\u0146\u0001\u0000\u0000\u0000\u09a2\u09a3\u0007\u000e\u0000\u0000\u09a3"+ + "\u09a4\u0007\u0014\u0000\u0000\u09a4\u09a5\u0007\n\u0000\u0000\u09a5\u09a6"+ + "\u0007\u000e\u0000\u0000\u09a6\u09a7\u0007\u0015\u0000\u0000\u09a7\u09a8"+ + "\u0007\u0018\u0000\u0000\u09a8\u09a9\u0007\u0013\u0000\u0000\u09a9\u09aa"+ + "\u0007\u0011\u0000\u0000\u09aa\u09ab\u0007\u0007\u0000\u0000\u09ab\u09ac"+ + "\u0007\u0010\u0000\u0000\u09ac\u0148\u0001\u0000\u0000\u0000\u09ad\u09ae"+ + "\u0007\u000e\u0000\u0000\u09ae\u09af\u0007\u0006\u0000\u0000\u09af\u09b0"+ + "\u0007\u0005\u0000\u0000\u09b0\u09b1\u0007\t\u0000\u0000\u09b1\u09b2\u0007"+ + "\t\u0000\u0000\u09b2\u014a\u0001\u0000\u0000\u0000\u09b3\u09b4\u0007\u000e"+ + "\u0000\u0000\u09b4\u09b5\u0007\u0006\u0000\u0000\u09b5\u09b6\u0007\u0013"+ + "\u0000\u0000\u09b6\u09b7\u0007\t\u0000\u0000\u09b7\u09b8\u0007\n\u0000"+ + "\u0000\u09b8\u014c\u0001\u0000\u0000\u0000\u09b9\u09ba\u0007\u000e\u0000"+ + "\u0000\u09ba\u09bb\u0007\u0006\u0000\u0000\u09bb\u09bc\u0007\u0016\u0000"+ + "\u0000\u09bc\u09bd\u0007\t\u0000\u0000\u09bd\u09be\u0007\u0010\u0000\u0000"+ + "\u09be\u09bf\u0007\n\u0000\u0000\u09bf\u09c0\u0007\r\u0000\u0000\u09c0"+ + "\u014e\u0001\u0000\u0000\u0000\u09c1\u09c2\u0007\u000e\u0000\u0000\u09c2"+ + "\u09c3\u0007\u0013\u0000\u0000\u09c3\u09c4\u0007\u000f\u0000\u0000\u09c4"+ + "\u09c5\u0007\u000f\u0000\u0000\u09c5\u09c6\u0007\n\u0000\u0000\u09c6\u09c7"+ + "\u0007\u0007\u0000\u0000\u09c7\u09c8\u0007\u0010\u0000\u0000\u09c8\u0150"+ + "\u0001\u0000\u0000\u0000\u09c9\u09ca\u0007\u000e\u0000\u0000\u09ca\u09cb"+ + "\u0007\u0013\u0000\u0000\u09cb\u09cc\u0007\u000f\u0000\u0000\u09cc\u09cd"+ + "\u0007\u000f\u0000\u0000\u09cd\u09ce\u0007\n\u0000\u0000\u09ce\u09cf\u0007"+ + "\u0007\u0000\u0000\u09cf\u09d0\u0007\u0010\u0000\u0000\u09d0\u09d1\u0007"+ + "\t\u0000\u0000\u09d1\u0152\u0001\u0000\u0000\u0000\u09d2\u09d3\u0007\u000e"+ + "\u0000\u0000\u09d3\u09d4\u0007\u0013\u0000\u0000\u09d4\u09d5\u0007\u000f"+ + "\u0000\u0000\u09d5\u09d6\u0007\u000f\u0000\u0000\u09d6\u09d7\u0007\u0011"+ + "\u0000\u0000\u09d7\u09d8\u0007\u0010\u0000\u0000\u09d8\u0154\u0001\u0000"+ + "\u0000\u0000\u09d9\u09da\u0007\u000e\u0000\u0000\u09da\u09db\u0007\u0013"+ + "\u0000\u0000\u09db\u09dc\u0007\u000f\u0000\u0000\u09dc\u09dd\u0007\u000f"+ + "\u0000\u0000\u09dd\u09de\u0007\u0011\u0000\u0000\u09de\u09df\u0007\u0010"+ + "\u0000\u0000\u09df\u09e0\u0007\u0010\u0000\u0000\u09e0\u09e1\u0007\n\u0000"+ + "\u0000\u09e1\u09e2\u0007\f\u0000\u0000\u09e2\u0156\u0001\u0000\u0000\u0000"+ + "\u09e3\u09e4\u0007\u000e\u0000\u0000\u09e4\u09e5\u0007\u0013\u0000\u0000"+ + "\u09e5\u09e6\u0007\u0007\u0000\u0000\u09e6\u09e7\u0007\u0019\u0000\u0000"+ + "\u09e7\u09e8\u0007\u0011\u0000\u0000\u09e8\u09e9\u0007\u0017\u0000\u0000"+ + "\u09e9\u09ea\u0007\u0016\u0000\u0000\u09ea\u09eb\u0007\r\u0000\u0000\u09eb"+ + "\u09ec\u0007\u0005\u0000\u0000\u09ec\u09ed\u0007\u0010\u0000\u0000\u09ed"+ + "\u09ee\u0007\u0011\u0000\u0000\u09ee\u09ef\u0007\u0013\u0000\u0000\u09ef"+ + "\u09f0\u0007\u0007\u0000\u0000\u09f0\u0158\u0001\u0000\u0000\u0000\u09f1"+ + "\u09f2\u0007\u000e\u0000\u0000\u09f2\u09f3\u0007\u0013\u0000\u0000\u09f3"+ + "\u09f4\u0007\u0007\u0000\u0000\u09f4\u09f5\u0007\u0007\u0000\u0000\u09f5"+ + "\u09f6\u0007\n\u0000\u0000\u09f6\u09f7\u0007\u000e\u0000\u0000\u09f7\u09f8"+ + "\u0007\u0010\u0000\u0000\u09f8\u09f9\u0007\u0011\u0000\u0000\u09f9\u09fa"+ + "\u0007\u0013\u0000\u0000\u09fa\u09fb\u0007\u0007\u0000\u0000\u09fb\u015a"+ + "\u0001\u0000\u0000\u0000\u09fc\u09fd\u0007\u000e\u0000\u0000\u09fd\u09fe"+ + "\u0007\u0013\u0000\u0000\u09fe\u09ff\u0007\u0007\u0000\u0000\u09ff\u0a00"+ + "\u0007\t\u0000\u0000\u0a00\u0a01\u0007\u0010\u0000\u0000\u0a01\u0a02\u0007"+ + "\r\u0000\u0000\u0a02\u0a03\u0007\u0005\u0000\u0000\u0a03\u0a04\u0007\u0011"+ + "\u0000\u0000\u0a04\u0a05\u0007\u0007\u0000\u0000\u0a05\u0a06\u0007\u0010"+ + "\u0000\u0000\u0a06\u0a07\u0007\t\u0000\u0000\u0a07\u015c\u0001\u0000\u0000"+ + "\u0000\u0a08\u0a09\u0007\u000e\u0000\u0000\u0a09\u0a0a\u0007\u0013\u0000"+ + "\u0000\u0a0a\u0a0b\u0007\u0007\u0000\u0000\u0a0b\u0a0c\u0007\u0010\u0000"+ + "\u0000\u0a0c\u0a0d\u0007\n\u0000\u0000\u0a0d\u0a0e\u0007\u0007\u0000\u0000"+ + "\u0a0e\u0a0f\u0007\u0010\u0000\u0000\u0a0f\u015e\u0001\u0000\u0000\u0000"+ + "\u0a10\u0a11\u0007\u000e\u0000\u0000\u0a11\u0a12\u0007\u0013\u0000\u0000"+ + "\u0a12\u0a13\u0007\u0007\u0000\u0000\u0a13\u0a14\u0007\u0010\u0000\u0000"+ + "\u0a14\u0a15\u0007\u0011\u0000\u0000\u0a15\u0a16\u0007\u0007\u0000\u0000"+ + "\u0a16\u0a17\u0007\u0016\u0000\u0000\u0a17\u0a18\u0007\n\u0000\u0000\u0a18"+ + "\u0160\u0001\u0000\u0000\u0000\u0a19\u0a1a\u0007\u000e\u0000\u0000\u0a1a"+ + "\u0a1b\u0007\u0013\u0000\u0000\u0a1b\u0a1c\u0007\u0007\u0000\u0000\u0a1c"+ + "\u0a1d\u0007\u001b\u0000\u0000\u0a1d\u0a1e\u0007\n\u0000\u0000\u0a1e\u0a1f"+ + "\u0007\r\u0000\u0000\u0a1f\u0a20\u0007\t\u0000\u0000\u0a20\u0a21\u0007"+ + "\u0011\u0000\u0000\u0a21\u0a22\u0007\u0013\u0000\u0000\u0a22\u0a23\u0007"+ + "\u0007\u0000\u0000\u0a23\u0162\u0001\u0000\u0000\u0000\u0a24\u0a25\u0007"+ + "\u000e\u0000\u0000\u0a25\u0a26\u0007\u0013\u0000\u0000\u0a26\u0a27\u0007"+ + "\u0018\u0000\u0000\u0a27\u0a28\u0007\b\u0000\u0000\u0a28\u0164\u0001\u0000"+ + "\u0000\u0000\u0a29\u0a2a\u0007\u000e\u0000\u0000\u0a2a\u0a2b\u0007\u0013"+ + "\u0000\u0000\u0a2b\u0a2c\u0007\t\u0000\u0000\u0a2c\u0a2d\u0007\u0010\u0000"+ + "\u0000\u0a2d\u0166\u0001\u0000\u0000\u0000\u0a2e\u0a2f\u0007\u000e\u0000"+ + "\u0000\u0a2f\u0a30\u0007\t\u0000\u0000\u0a30\u0a31\u0007\u001b\u0000\u0000"+ + "\u0a31\u0168\u0001\u0000\u0000\u0000\u0a32\u0a33\u0007\u000e\u0000\u0000"+ + "\u0a33\u0a34\u0007\u0016\u0000\u0000\u0a34\u0a35\u0007\r\u0000\u0000\u0a35"+ + "\u0a36\u0007\t\u0000\u0000\u0a36\u0a37\u0007\u0013\u0000\u0000\u0a37\u0a38"+ + "\u0007\r\u0000\u0000\u0a38\u016a\u0001\u0000\u0000\u0000\u0a39\u0a3a\u0007"+ + "\u000e\u0000\u0000\u0a3a\u0a3b\u0007\b\u0000\u0000\u0a3b\u0a3c\u0007\u000e"+ + "\u0000\u0000\u0a3c\u0a3d\u0007\u0006\u0000\u0000\u0a3d\u0a3e\u0007\n\u0000"+ + "\u0000\u0a3e\u016c\u0001\u0000\u0000\u0000\u0a3f\u0a40\u0007\f\u0000\u0000"+ + "\u0a40\u0a41\u0007\u0005\u0000\u0000\u0a41\u0a42\u0007\u0010\u0000\u0000"+ + "\u0a42\u0a43\u0007\u0005\u0000\u0000\u0a43\u016e\u0001\u0000\u0000\u0000"+ + "\u0a44\u0a45\u0007\f\u0000\u0000\u0a45\u0a46\u0007\u0005\u0000\u0000\u0a46"+ + "\u0a47\u0007\u0010\u0000\u0000\u0a47\u0a48\u0007\u0005\u0000\u0000\u0a48"+ + "\u0a49\u0007\u0012\u0000\u0000\u0a49\u0a4a\u0007\u0005\u0000\u0000\u0a4a"+ + "\u0a4b\u0007\t\u0000\u0000\u0a4b\u0a4c\u0007\n\u0000\u0000\u0a4c\u0170"+ + "\u0001\u0000\u0000\u0000\u0a4d\u0a4e\u0007\f\u0000\u0000\u0a4e\u0a4f\u0007"+ + "\u0005\u0000\u0000\u0a4f\u0a50\u0007\b\u0000\u0000\u0a50\u0172\u0001\u0000"+ + "\u0000\u0000\u0a51\u0a52\u0007\f\u0000\u0000\u0a52\u0a53\u0007\n\u0000"+ + "\u0000\u0a53\u0a54\u0007\u0005\u0000\u0000\u0a54\u0a55\u0007\u0006\u0000"+ + "\u0000\u0a55\u0a56\u0007\u0006\u0000\u0000\u0a56\u0a57\u0007\u0013\u0000"+ + "\u0000\u0a57\u0a58\u0007\u000e\u0000\u0000\u0a58\u0a59\u0007\u0005\u0000"+ + "\u0000\u0a59\u0a5a\u0007\u0010\u0000\u0000\u0a5a\u0a5b\u0007\n\u0000\u0000"+ + "\u0a5b\u0174\u0001\u0000\u0000\u0000\u0a5c\u0a5d\u0007\f\u0000\u0000\u0a5d"+ + "\u0a5e\u0007\n\u0000\u0000\u0a5e\u0a5f\u0007\u000e\u0000\u0000\u0a5f\u0a60"+ + "\u0007\u0006\u0000\u0000\u0a60\u0a61\u0007\u0005\u0000\u0000\u0a61\u0a62"+ + "\u0007\r\u0000\u0000\u0a62\u0a63\u0007\n\u0000\u0000\u0a63\u0176\u0001"+ + "\u0000\u0000\u0000\u0a64\u0a65\u0007\f\u0000\u0000\u0a65\u0a66\u0007\n"+ + "\u0000\u0000\u0a66\u0a67\u0007\u0019\u0000\u0000\u0a67\u0a68\u0007\u0005"+ + "\u0000\u0000\u0a68\u0a69\u0007\u0016\u0000\u0000\u0a69\u0a6a\u0007\u0006"+ + "\u0000\u0000\u0a6a\u0a6b\u0007\u0010\u0000\u0000\u0a6b\u0a6c\u0007\t\u0000"+ + "\u0000\u0a6c\u0178\u0001\u0000\u0000\u0000\u0a6d\u0a6e\u0007\f\u0000\u0000"+ + "\u0a6e\u0a6f\u0007\n\u0000\u0000\u0a6f\u0a70\u0007\u0019\u0000\u0000\u0a70"+ + "\u0a71\u0007\n\u0000\u0000\u0a71\u0a72\u0007\r\u0000\u0000\u0a72\u0a73"+ + "\u0007\r\u0000\u0000\u0a73\u0a74\u0007\n\u0000\u0000\u0a74\u0a75\u0007"+ + "\f\u0000\u0000\u0a75\u017a\u0001\u0000\u0000\u0000\u0a76\u0a77\u0007\f"+ + "\u0000\u0000\u0a77\u0a78\u0007\n\u0000\u0000\u0a78\u0a79\u0007\u0019\u0000"+ + "\u0000\u0a79\u0a7a\u0007\u0011\u0000\u0000\u0a7a\u0a7b\u0007\u0007\u0000"+ + "\u0000\u0a7b\u0a7c\u0007\n\u0000\u0000\u0a7c\u0a7d\u0007\r\u0000\u0000"+ + "\u0a7d\u017c\u0001\u0000\u0000\u0000\u0a7e\u0a7f\u0007\f\u0000\u0000\u0a7f"+ + "\u0a80\u0007\n\u0000\u0000\u0a80\u0a81\u0007\u0006\u0000\u0000\u0a81\u0a82"+ + "\u0007\n\u0000\u0000\u0a82\u0a83\u0007\u0010\u0000\u0000\u0a83\u0a84\u0007"+ + "\n\u0000\u0000\u0a84\u017e\u0001\u0000\u0000\u0000\u0a85\u0a86\u0007\f"+ + "\u0000\u0000\u0a86\u0a87\u0007\n\u0000\u0000\u0a87\u0a88\u0007\u0006\u0000"+ + "\u0000\u0a88\u0a89\u0007\u0011\u0000\u0000\u0a89\u0a8a\u0007\u000f\u0000"+ + "\u0000\u0a8a\u0a8b\u0007\u0011\u0000\u0000\u0a8b\u0a8c\u0007\u0010\u0000"+ + "\u0000\u0a8c\u0a8d\u0007\n\u0000\u0000\u0a8d\u0a8e\u0007\r\u0000\u0000"+ + "\u0a8e\u0180\u0001\u0000\u0000\u0000\u0a8f\u0a90\u0007\f\u0000\u0000\u0a90"+ + "\u0a91\u0007\n\u0000\u0000\u0a91\u0a92\u0007\u0006\u0000\u0000\u0a92\u0a93"+ + "\u0007\u0011\u0000\u0000\u0a93\u0a94\u0007\u000f\u0000\u0000\u0a94\u0a95"+ + "\u0007\u0011\u0000\u0000\u0a95\u0a96\u0007\u0010\u0000\u0000\u0a96\u0a97"+ + "\u0007\n\u0000\u0000\u0a97\u0a98\u0007\r\u0000\u0000\u0a98\u0a99\u0007"+ + "\t\u0000\u0000\u0a99\u0182\u0001\u0000\u0000\u0000\u0a9a\u0a9b\u0007\f"+ + "\u0000\u0000\u0a9b\u0a9c\u0007\u0011\u0000\u0000\u0a9c\u0a9d\u0007\u000e"+ + "\u0000\u0000\u0a9d\u0a9e\u0007\u0010\u0000\u0000\u0a9e\u0a9f\u0007\u0011"+ + "\u0000\u0000\u0a9f\u0aa0\u0007\u0013\u0000\u0000\u0aa0\u0aa1\u0007\u0007"+ + "\u0000\u0000\u0aa1\u0aa2\u0007\u0005\u0000\u0000\u0aa2\u0aa3\u0007\r\u0000"+ + "\u0000\u0aa3\u0aa4\u0007\b\u0000\u0000\u0aa4\u0184\u0001\u0000\u0000\u0000"+ + "\u0aa5\u0aa6\u0007\f\u0000\u0000\u0aa6\u0aa7\u0007\u0011\u0000\u0000\u0aa7"+ + "\u0aa8\u0007\t\u0000\u0000\u0aa8\u0aa9\u0007\u0005\u0000\u0000\u0aa9\u0aaa"+ + "\u0007\u0012\u0000\u0000\u0aaa\u0aab\u0007\u0006\u0000\u0000\u0aab\u0aac"+ + "\u0007\n\u0000\u0000\u0aac\u0186\u0001\u0000\u0000\u0000\u0aad\u0aae\u0007"+ + "\f\u0000\u0000\u0aae\u0aaf\u0007\u0011\u0000\u0000\u0aaf\u0ab0\u0007\t"+ + "\u0000\u0000\u0ab0\u0ab1\u0007\u000e\u0000\u0000\u0ab1\u0ab2\u0007\u0005"+ + "\u0000\u0000\u0ab2\u0ab3\u0007\r\u0000\u0000\u0ab3\u0ab4\u0007\f\u0000"+ + "\u0000\u0ab4\u0188\u0001\u0000\u0000\u0000\u0ab5\u0ab6\u0007\f\u0000\u0000"+ + "\u0ab6\u0ab7\u0007\u0013\u0000\u0000\u0ab7\u0ab8\u0007\u000e\u0000\u0000"+ + "\u0ab8\u0ab9\u0007\u0016\u0000\u0000\u0ab9\u0aba\u0007\u000f\u0000\u0000"+ + "\u0aba\u0abb\u0007\n\u0000\u0000\u0abb\u0abc\u0007\u0007\u0000\u0000\u0abc"+ + "\u0abd\u0007\u0010\u0000\u0000\u0abd\u018a\u0001\u0000\u0000\u0000\u0abe"+ + "\u0abf\u0007\f\u0000\u0000\u0abf\u0ac0\u0007\u0013\u0000\u0000\u0ac0\u0ac1"+ + "\u0007\u000f\u0000\u0000\u0ac1\u0ac2\u0007\u0005\u0000\u0000\u0ac2\u0ac3"+ + "\u0007\u0011\u0000\u0000\u0ac3\u0ac4\u0007\u0007\u0000\u0000\u0ac4\u018c"+ + "\u0001\u0000\u0000\u0000\u0ac5\u0ac6\u0007\f\u0000\u0000\u0ac6\u0ac7\u0007"+ + "\u0013\u0000\u0000\u0ac7\u0ac8\u0007\u0016\u0000\u0000\u0ac8\u0ac9\u0007"+ + "\u0012\u0000\u0000\u0ac9\u0aca\u0007\u0006\u0000\u0000\u0aca\u0acb\u0007"+ + "\n\u0000\u0000\u0acb\u018e\u0001\u0000\u0000\u0000\u0acc\u0acd\u0007\f"+ + "\u0000\u0000\u0acd\u0ace\u0007\r\u0000\u0000\u0ace\u0acf\u0007\u0013\u0000"+ + "\u0000\u0acf\u0ad0\u0007\u0018\u0000\u0000\u0ad0\u0190\u0001\u0000\u0000"+ + "\u0000\u0ad1\u0ad2\u0007\n\u0000\u0000\u0ad2\u0ad3\u0007\u0005\u0000\u0000"+ + "\u0ad3\u0ad4\u0007\u000e\u0000\u0000\u0ad4\u0ad5\u0007\u0014\u0000\u0000"+ + "\u0ad5\u0192\u0001\u0000\u0000\u0000\u0ad6\u0ad7\u0007\n\u0000\u0000\u0ad7"+ + "\u0ad8\u0007\u0007\u0000\u0000\u0ad8\u0ad9\u0007\u0005\u0000\u0000\u0ad9"+ + "\u0ada\u0007\u0012\u0000\u0000\u0ada\u0adb\u0007\u0006\u0000\u0000\u0adb"+ + "\u0adc\u0007\n\u0000\u0000\u0adc\u0194\u0001\u0000\u0000\u0000\u0add\u0ade"+ + "\u0007\n\u0000\u0000\u0ade\u0adf\u0007\u0007\u0000\u0000\u0adf\u0ae0\u0007"+ + "\u000e\u0000\u0000\u0ae0\u0ae1\u0007\u0013\u0000\u0000\u0ae1\u0ae2\u0007"+ + "\f\u0000\u0000\u0ae2\u0ae3\u0007\u0011\u0000\u0000\u0ae3\u0ae4\u0007\u0007"+ + "\u0000\u0000\u0ae4\u0ae5\u0007\u0017\u0000\u0000\u0ae5\u0196\u0001\u0000"+ + "\u0000\u0000\u0ae6\u0ae7\u0007\n\u0000\u0000\u0ae7\u0ae8\u0007\u0007\u0000"+ + "\u0000\u0ae8\u0ae9\u0007\u000e\u0000\u0000\u0ae9\u0aea\u0007\r\u0000\u0000"+ + "\u0aea\u0aeb\u0007\b\u0000\u0000\u0aeb\u0aec\u0007\u0018\u0000\u0000\u0aec"+ + "\u0aed\u0007\u0010\u0000\u0000\u0aed\u0aee\u0007\n\u0000\u0000\u0aee\u0aef"+ + "\u0007\f\u0000\u0000\u0aef\u0198\u0001\u0000\u0000\u0000\u0af0\u0af1\u0007"+ + "\n\u0000\u0000\u0af1\u0af2\u0007\u0007\u0000\u0000\u0af2\u0af3\u0007\u0016"+ + "\u0000\u0000\u0af3\u0af4\u0007\u000f\u0000\u0000\u0af4\u019a\u0001\u0000"+ + "\u0000\u0000\u0af5\u0af6\u0007\n\u0000\u0000\u0af6\u0af7\u0007\t\u0000"+ + "\u0000\u0af7\u0af8\u0007\u000e\u0000\u0000\u0af8\u0af9\u0007\u0005\u0000"+ + "\u0000\u0af9\u0afa\u0007\u0018\u0000\u0000\u0afa\u0afb\u0007\n\u0000\u0000"+ + "\u0afb\u019c\u0001\u0000\u0000\u0000\u0afc\u0afd\u0007\n\u0000\u0000\u0afd"+ + "\u0afe\u0007\u001b\u0000\u0000\u0afe\u0aff\u0007\n\u0000\u0000\u0aff\u0b00"+ + "\u0007\u0007\u0000\u0000\u0b00\u0b01\u0007\u0010\u0000\u0000\u0b01\u019e"+ + "\u0001\u0000\u0000\u0000\u0b02\u0b03\u0007\n\u0000\u0000\u0b03\u0b04\u0007"+ + "\u001a\u0000\u0000\u0b04\u0b05\u0007\u000e\u0000\u0000\u0b05\u0b06\u0007"+ + "\u0006\u0000\u0000\u0b06\u0b07\u0007\u0016\u0000\u0000\u0b07\u0b08\u0007"+ + "\f\u0000\u0000\u0b08\u0b09\u0007\n\u0000\u0000\u0b09\u01a0\u0001\u0000"+ + "\u0000\u0000\u0b0a\u0b0b\u0007\n\u0000\u0000\u0b0b\u0b0c\u0007\u001a\u0000"+ + "\u0000\u0b0c\u0b0d\u0007\u000e\u0000\u0000\u0b0d\u0b0e\u0007\u0006\u0000"+ + "\u0000\u0b0e\u0b0f\u0007\u0016\u0000\u0000\u0b0f\u0b10\u0007\f\u0000\u0000"+ + "\u0b10\u0b11\u0007\u0011\u0000\u0000\u0b11\u0b12\u0007\u0007\u0000\u0000"+ + "\u0b12\u0b13\u0007\u0017\u0000\u0000\u0b13\u01a2\u0001\u0000\u0000\u0000"+ + "\u0b14\u0b15\u0007\n\u0000\u0000\u0b15\u0b16\u0007\u001a\u0000\u0000\u0b16"+ + "\u0b17\u0007\u000e\u0000\u0000\u0b17\u0b18\u0007\u0006\u0000\u0000\u0b18"+ + "\u0b19\u0007\u0016\u0000\u0000\u0b19\u0b1a\u0007\t\u0000\u0000\u0b1a\u0b1b"+ + "\u0007\u0011\u0000\u0000\u0b1b\u0b1c\u0007\u001b\u0000\u0000\u0b1c\u0b1d"+ + "\u0007\n\u0000\u0000\u0b1d\u01a4\u0001\u0000\u0000\u0000\u0b1e\u0b1f\u0007"+ + "\n\u0000\u0000\u0b1f\u0b20\u0007\u001a\u0000\u0000\u0b20\u0b21\u0007\n"+ + "\u0000\u0000\u0b21\u0b22\u0007\u000e\u0000\u0000\u0b22\u0b23\u0007\u0016"+ + "\u0000\u0000\u0b23\u0b24\u0007\u0010\u0000\u0000\u0b24\u0b25\u0007\n\u0000"+ + "\u0000\u0b25\u01a6\u0001\u0000\u0000\u0000\u0b26\u0b27\u0007\n\u0000\u0000"+ + "\u0b27\u0b28\u0007\u001a\u0000\u0000\u0b28\u0b29\u0007\u0018\u0000\u0000"+ + "\u0b29\u0b2a\u0007\u0006\u0000\u0000\u0b2a\u0b2b\u0007\u0005\u0000\u0000"+ + "\u0b2b\u0b2c\u0007\u0011\u0000\u0000\u0b2c\u0b2d\u0007\u0007\u0000\u0000"+ + "\u0b2d\u01a8\u0001\u0000\u0000\u0000\u0b2e\u0b2f\u0007\n\u0000\u0000\u0b2f"+ + "\u0b30\u0007\u001a\u0000\u0000\u0b30\u0b31\u0007\u0010\u0000\u0000\u0b31"+ + "\u0b32\u0007\n\u0000\u0000\u0b32\u0b33\u0007\u0007\u0000\u0000\u0b33\u0b34"+ + "\u0007\t\u0000\u0000\u0b34\u0b35\u0007\u0011\u0000\u0000\u0b35\u0b36\u0007"+ + "\u0013\u0000\u0000\u0b36\u0b37\u0007\u0007\u0000\u0000\u0b37\u01aa\u0001"+ + "\u0000\u0000\u0000\u0b38\u0b39\u0007\n\u0000\u0000\u0b39\u0b3a\u0007\u001a"+ + "\u0000\u0000\u0b3a\u0b3b\u0007\u0010\u0000\u0000\u0b3b\u0b3c\u0007\n\u0000"+ + "\u0000\u0b3c\u0b3d\u0007\r\u0000\u0000\u0b3d\u0b3e\u0007\u0007\u0000\u0000"+ + "\u0b3e\u0b3f\u0007\u0005\u0000\u0000\u0b3f\u0b40\u0007\u0006\u0000\u0000"+ + "\u0b40\u01ac\u0001\u0000\u0000\u0000\u0b41\u0b42\u0007\u0019\u0000\u0000"+ + "\u0b42\u0b43\u0007\u0005\u0000\u0000\u0b43\u0b44\u0007\u000f\u0000\u0000"+ + "\u0b44\u0b45\u0007\u0011\u0000\u0000\u0b45\u0b46\u0007\u0006\u0000\u0000"+ + "\u0b46\u0b47\u0007\b\u0000\u0000\u0b47\u01ae\u0001\u0000\u0000\u0000\u0b48"+ + "\u0b49\u0007\u0019\u0000\u0000\u0b49\u0b4a\u0007\u0011\u0000\u0000\u0b4a"+ + "\u0b4b\u0007\r\u0000\u0000\u0b4b\u0b4c\u0007\t\u0000\u0000\u0b4c\u0b4d"+ + "\u0007\u0010\u0000\u0000\u0b4d\u01b0\u0001\u0000\u0000\u0000\u0b4e\u0b4f"+ + "\u0007\u0019\u0000\u0000\u0b4f\u0b50\u0007\u0013\u0000\u0000\u0b50\u0b51"+ + "\u0007\u0006\u0000\u0000\u0b51\u0b52\u0007\u0006\u0000\u0000\u0b52\u0b53"+ + "\u0007\u0013\u0000\u0000\u0b53\u0b54\u0007\u001d\u0000\u0000\u0b54\u0b55"+ + "\u0007\u0011\u0000\u0000\u0b55\u0b56\u0007\u0007\u0000\u0000\u0b56\u0b57"+ + "\u0007\u0017\u0000\u0000\u0b57\u01b2\u0001\u0000\u0000\u0000\u0b58\u0b59"+ + "\u0007\u0019\u0000\u0000\u0b59\u0b5a\u0007\u0013\u0000\u0000\u0b5a\u0b5b"+ + "\u0007\r\u0000\u0000\u0b5b\u0b5c\u0007\u000e\u0000\u0000\u0b5c\u0b5d\u0007"+ + "\n\u0000\u0000\u0b5d\u01b4\u0001\u0000\u0000\u0000\u0b5e\u0b5f\u0007\u0019"+ + "\u0000\u0000\u0b5f\u0b60\u0007\u0013\u0000\u0000\u0b60\u0b61\u0007\r\u0000"+ + "\u0000\u0b61\u0b62\u0007\u001d\u0000\u0000\u0b62\u0b63\u0007\u0005\u0000"+ + "\u0000\u0b63\u0b64\u0007\r\u0000\u0000\u0b64\u0b65\u0007\f\u0000\u0000"+ + "\u0b65\u01b6\u0001\u0000\u0000\u0000\u0b66\u0b67\u0007\u0019\u0000\u0000"+ + "\u0b67\u0b68\u0007\u0016\u0000\u0000\u0b68\u0b69\u0007\u0007\u0000\u0000"+ + "\u0b69\u0b6a\u0007\u000e\u0000\u0000\u0b6a\u0b6b\u0007\u0010\u0000\u0000"+ + "\u0b6b\u0b6c\u0007\u0011\u0000\u0000\u0b6c\u0b6d\u0007\u0013\u0000\u0000"+ + "\u0b6d\u0b6e\u0007\u0007\u0000\u0000\u0b6e\u01b8\u0001\u0000\u0000\u0000"+ + "\u0b6f\u0b70\u0007\u0019\u0000\u0000\u0b70\u0b71\u0007\u0016\u0000\u0000"+ + "\u0b71\u0b72\u0007\u0007\u0000\u0000\u0b72\u0b73\u0007\u000e\u0000\u0000"+ + "\u0b73\u0b74\u0007\u0010\u0000\u0000\u0b74\u0b75\u0007\u0011\u0000\u0000"+ + "\u0b75\u0b76\u0007\u0013\u0000\u0000\u0b76\u0b77\u0007\u0007\u0000\u0000"+ + "\u0b77\u0b78\u0007\t\u0000\u0000\u0b78\u01ba\u0001\u0000\u0000\u0000\u0b79"+ + "\u0b7a\u0007\u0017\u0000\u0000\u0b7a\u0b7b\u0007\u0006\u0000\u0000\u0b7b"+ + "\u0b7c\u0007\u0013\u0000\u0000\u0b7c\u0b7d\u0007\u0012\u0000\u0000\u0b7d"+ + "\u0b7e\u0007\u0005\u0000\u0000\u0b7e\u0b7f\u0007\u0006\u0000\u0000\u0b7f"+ + "\u01bc\u0001\u0000\u0000\u0000\u0b80\u0b81\u0007\u0017\u0000\u0000\u0b81"+ + "\u0b82\u0007\r\u0000\u0000\u0b82\u0b83\u0007\u0005\u0000\u0000\u0b83\u0b84"+ + "\u0007\u0007\u0000\u0000\u0b84\u0b85\u0007\u0010\u0000\u0000\u0b85\u0b86"+ + "\u0007\n\u0000\u0000\u0b86\u0b87\u0007\f\u0000\u0000\u0b87\u01be\u0001"+ + "\u0000\u0000\u0000\u0b88\u0b89\u0007\u0014\u0000\u0000\u0b89\u0b8a\u0007"+ + "\u0005\u0000\u0000\u0b8a\u0b8b\u0007\u0007\u0000\u0000\u0b8b\u0b8c\u0007"+ + "\f\u0000\u0000\u0b8c\u0b8d\u0007\u0006\u0000\u0000\u0b8d\u0b8e\u0007\n"+ + "\u0000\u0000\u0b8e\u0b8f\u0007\r\u0000\u0000\u0b8f\u01c0\u0001\u0000\u0000"+ + "\u0000\u0b90\u0b91\u0007\u0014\u0000\u0000\u0b91\u0b92\u0007\n\u0000\u0000"+ + "\u0b92\u0b93\u0007\u0005\u0000\u0000\u0b93\u0b94\u0007\f\u0000\u0000\u0b94"+ + "\u0b95\u0007\n\u0000\u0000\u0b95\u0b96\u0007\r\u0000\u0000\u0b96\u01c2"+ + "\u0001\u0000\u0000\u0000\u0b97\u0b98\u0007\u0014\u0000\u0000\u0b98\u0b99"+ + "\u0007\u0013\u0000\u0000\u0b99\u0b9a\u0007\u0006\u0000\u0000\u0b9a\u0b9b"+ + "\u0007\f\u0000\u0000\u0b9b\u01c4\u0001\u0000\u0000\u0000\u0b9c\u0b9d\u0007"+ + "\u0014\u0000\u0000\u0b9d\u0b9e\u0007\u0013\u0000\u0000\u0b9e\u0b9f\u0007"+ + "\u0016\u0000\u0000\u0b9f\u0ba0\u0007\r\u0000\u0000\u0ba0\u01c6\u0001\u0000"+ + "\u0000\u0000\u0ba1\u0ba2\u0007\u0011\u0000\u0000\u0ba2\u0ba3\u0007\f\u0000"+ + "\u0000\u0ba3\u0ba4\u0007\n\u0000\u0000\u0ba4\u0ba5\u0007\u0007\u0000\u0000"+ + "\u0ba5\u0ba6\u0007\u0010\u0000\u0000\u0ba6\u0ba7\u0007\u0011\u0000\u0000"+ + "\u0ba7\u0ba8\u0007\u0010\u0000\u0000\u0ba8\u0ba9\u0007\b\u0000\u0000\u0ba9"+ + "\u01c8\u0001\u0000\u0000\u0000\u0baa\u0bab\u0007\u0011\u0000\u0000\u0bab"+ + "\u0bac\u0007\u0019\u0000\u0000\u0bac\u01ca\u0001\u0000\u0000\u0000\u0bad"+ + "\u0bae\u0007\u0011\u0000\u0000\u0bae\u0baf\u0007\u000f\u0000\u0000\u0baf"+ + "\u0bb0\u0007\u000f\u0000\u0000\u0bb0\u0bb1\u0007\n\u0000\u0000\u0bb1\u0bb2"+ + "\u0007\f\u0000\u0000\u0bb2\u0bb3\u0007\u0011\u0000\u0000\u0bb3\u0bb4\u0007"+ + "\u0005\u0000\u0000\u0bb4\u0bb5\u0007\u0010\u0000\u0000\u0bb5\u0bb6\u0007"+ + "\n\u0000\u0000\u0bb6\u01cc\u0001\u0000\u0000\u0000\u0bb7\u0bb8\u0007\u0011"+ + "\u0000\u0000\u0bb8\u0bb9\u0007\u000f\u0000\u0000\u0bb9\u0bba\u0007\u000f"+ + "\u0000\u0000\u0bba\u0bbb\u0007\u0016\u0000\u0000\u0bbb\u0bbc\u0007\u0010"+ + "\u0000\u0000\u0bbc\u0bbd\u0007\u0005\u0000\u0000\u0bbd\u0bbe\u0007\u0012"+ + "\u0000\u0000\u0bbe\u0bbf\u0007\u0006\u0000\u0000\u0bbf\u0bc0\u0007\n\u0000"+ + "\u0000\u0bc0\u01ce\u0001\u0000\u0000\u0000\u0bc1\u0bc2\u0007\u0011\u0000"+ + "\u0000\u0bc2\u0bc3\u0007\u000f\u0000\u0000\u0bc3\u0bc4\u0007\u0018\u0000"+ + "\u0000\u0bc4\u0bc5\u0007\u0006\u0000\u0000\u0bc5\u0bc6\u0007\u0011\u0000"+ + "\u0000\u0bc6\u0bc7\u0007\u000e\u0000\u0000\u0bc7\u0bc8\u0007\u0011\u0000"+ + "\u0000\u0bc8\u0bc9\u0007\u0010\u0000\u0000\u0bc9\u01d0\u0001\u0000\u0000"+ + "\u0000\u0bca\u0bcb\u0007\u0011\u0000\u0000\u0bcb\u0bcc\u0007\u0007\u0000"+ + "\u0000\u0bcc\u0bcd\u0007\u000e\u0000\u0000\u0bcd\u0bce\u0007\u0006\u0000"+ + "\u0000\u0bce\u0bcf\u0007\u0016\u0000\u0000\u0bcf\u0bd0\u0007\f\u0000\u0000"+ + "\u0bd0\u0bd1\u0007\u0011\u0000\u0000\u0bd1\u0bd2\u0007\u0007\u0000\u0000"+ + "\u0bd2\u0bd3\u0007\u0017\u0000\u0000\u0bd3\u01d2\u0001\u0000\u0000\u0000"+ + "\u0bd4\u0bd5\u0007\u0011\u0000\u0000\u0bd5\u0bd6\u0007\u0007\u0000\u0000"+ + "\u0bd6\u0bd7\u0007\u000e\u0000\u0000\u0bd7\u0bd8\u0007\r\u0000\u0000\u0bd8"+ + "\u0bd9\u0007\n\u0000\u0000\u0bd9\u0bda\u0007\u000f\u0000\u0000\u0bda\u0bdb"+ + "\u0007\n\u0000\u0000\u0bdb\u0bdc\u0007\u0007\u0000\u0000\u0bdc\u0bdd\u0007"+ + "\u0010\u0000\u0000\u0bdd\u01d4\u0001\u0000\u0000\u0000\u0bde\u0bdf\u0007"+ + "\u0011\u0000\u0000\u0bdf\u0be0\u0007\u0007\u0000\u0000\u0be0\u0be1\u0007"+ + "\f\u0000\u0000\u0be1\u0be2\u0007\n\u0000\u0000\u0be2\u0be3\u0007\u001a"+ + "\u0000\u0000\u0be3\u01d6\u0001\u0000\u0000\u0000\u0be4\u0be5\u0007\u0011"+ + "\u0000\u0000\u0be5\u0be6\u0007\u0007\u0000\u0000\u0be6\u0be7\u0007\f\u0000"+ + "\u0000\u0be7\u0be8\u0007\n\u0000\u0000\u0be8\u0be9\u0007\u001a\u0000\u0000"+ + "\u0be9\u0bea\u0007\n\u0000\u0000\u0bea\u0beb\u0007\t\u0000\u0000\u0beb"+ + "\u01d8\u0001\u0000\u0000\u0000\u0bec\u0bed\u0007\u0011\u0000\u0000\u0bed"+ + "\u0bee\u0007\u0007\u0000\u0000\u0bee\u0bef\u0007\u0014\u0000\u0000\u0bef"+ + "\u0bf0\u0007\n\u0000\u0000\u0bf0\u0bf1\u0007\r\u0000\u0000\u0bf1\u0bf2"+ + "\u0007\u0011\u0000\u0000\u0bf2\u0bf3\u0007\u0010\u0000\u0000\u0bf3\u01da"+ + "\u0001\u0000\u0000\u0000\u0bf4\u0bf5\u0007\u0011\u0000\u0000\u0bf5\u0bf6"+ + "\u0007\u0007\u0000\u0000\u0bf6\u0bf7\u0007\u0014\u0000\u0000\u0bf7\u0bf8"+ + "\u0007\n\u0000\u0000\u0bf8\u0bf9\u0007\r\u0000\u0000\u0bf9\u0bfa\u0007"+ + "\u0011\u0000\u0000\u0bfa\u0bfb\u0007\u0010\u0000\u0000\u0bfb\u0bfc\u0007"+ + "\t\u0000\u0000\u0bfc\u01dc\u0001\u0000\u0000\u0000\u0bfd\u0bfe\u0007\u0011"+ + "\u0000\u0000\u0bfe\u0bff\u0007\u0007\u0000\u0000\u0bff\u0c00\u0007\u0006"+ + "\u0000\u0000\u0c00\u0c01\u0007\u0011\u0000\u0000\u0c01\u0c02\u0007\u0007"+ + "\u0000\u0000\u0c02\u0c03\u0007\n\u0000\u0000\u0c03\u01de\u0001\u0000\u0000"+ + "\u0000\u0c04\u0c05\u0007\u0011\u0000\u0000\u0c05\u0c06\u0007\u0007\u0000"+ + "\u0000\u0c06\u0c07\u0007\t\u0000\u0000\u0c07\u0c08\u0007\n\u0000\u0000"+ + "\u0c08\u0c09\u0007\u0007\u0000\u0000\u0c09\u0c0a\u0007\t\u0000\u0000\u0c0a"+ + "\u0c0b\u0007\u0011\u0000\u0000\u0c0b\u0c0c\u0007\u0010\u0000\u0000\u0c0c"+ + "\u0c0d\u0007\u0011\u0000\u0000\u0c0d\u0c0e\u0007\u001b\u0000\u0000\u0c0e"+ + "\u0c0f\u0007\n\u0000\u0000\u0c0f\u01e0\u0001\u0000\u0000\u0000\u0c10\u0c11"+ + "\u0007\u0011\u0000\u0000\u0c11\u0c12\u0007\u0007\u0000\u0000\u0c12\u0c13"+ + "\u0007\t\u0000\u0000\u0c13\u0c14\u0007\n\u0000\u0000\u0c14\u0c15\u0007"+ + "\r\u0000\u0000\u0c15\u0c16\u0007\u0010\u0000\u0000\u0c16\u01e2\u0001\u0000"+ + "\u0000\u0000\u0c17\u0c18\u0007\u0011\u0000\u0000\u0c18\u0c19\u0007\u0007"+ + "\u0000\u0000\u0c19\u0c1a\u0007\t\u0000\u0000\u0c1a\u0c1b\u0007\u0010\u0000"+ + "\u0000\u0c1b\u0c1c\u0007\n\u0000\u0000\u0c1c\u0c1d\u0007\u0005\u0000\u0000"+ + "\u0c1d\u0c1e\u0007\f\u0000\u0000\u0c1e\u01e4\u0001\u0000\u0000\u0000\u0c1f"+ + "\u0c20\u0007\u0011\u0000\u0000\u0c20\u0c21\u0007\u0007\u0000\u0000\u0c21"+ + "\u0c22\u0007\u001b\u0000\u0000\u0c22\u0c23\u0007\u0013\u0000\u0000\u0c23"+ + "\u0c24\u0007\u0015\u0000\u0000\u0c24\u0c25\u0007\n\u0000\u0000\u0c25\u0c26"+ + "\u0007\r\u0000\u0000\u0c26\u01e6\u0001\u0000\u0000\u0000\u0c27\u0c28\u0007"+ + "\u0011\u0000\u0000\u0c28\u0c29\u0007\t\u0000\u0000\u0c29\u0c2a\u0007\u0013"+ + "\u0000\u0000\u0c2a\u0c2b\u0007\u0006\u0000\u0000\u0c2b\u0c2c\u0007\u0005"+ + "\u0000\u0000\u0c2c\u0c2d\u0007\u0010\u0000\u0000\u0c2d\u0c2e\u0007\u0011"+ + "\u0000\u0000\u0c2e\u0c2f\u0007\u0013\u0000\u0000\u0c2f\u0c30\u0007\u0007"+ + "\u0000\u0000\u0c30\u01e8\u0001\u0000\u0000\u0000\u0c31\u0c32\u0007\u0015"+ + "\u0000\u0000\u0c32\u0c33\u0007\n\u0000\u0000\u0c33\u0c34\u0007\b\u0000"+ + "\u0000\u0c34\u01ea\u0001\u0000\u0000\u0000\u0c35\u0c36\u0007\u0006\u0000"+ + "\u0000\u0c36\u0c37\u0007\u0005\u0000\u0000\u0c37\u0c38\u0007\u0012\u0000"+ + "\u0000\u0c38\u0c39\u0007\n\u0000\u0000\u0c39\u0c3a\u0007\u0006\u0000\u0000"+ + "\u0c3a\u01ec\u0001\u0000\u0000\u0000\u0c3b\u0c3c\u0007\u0006\u0000\u0000"+ + "\u0c3c\u0c3d\u0007\u0005\u0000\u0000\u0c3d\u0c3e\u0007\u0007\u0000\u0000"+ + "\u0c3e\u0c3f\u0007\u0017\u0000\u0000\u0c3f\u0c40\u0007\u0016\u0000\u0000"+ + "\u0c40\u0c41\u0007\u0005\u0000\u0000\u0c41\u0c42\u0007\u0017\u0000\u0000"+ + "\u0c42\u0c43\u0007\n\u0000\u0000\u0c43\u01ee\u0001\u0000\u0000\u0000\u0c44"+ + "\u0c45\u0007\u0006\u0000\u0000\u0c45\u0c46\u0007\u0005\u0000\u0000\u0c46"+ + "\u0c47\u0007\r\u0000\u0000\u0c47\u0c48\u0007\u0017\u0000\u0000\u0c48\u0c49"+ + "\u0007\n\u0000\u0000\u0c49\u01f0\u0001\u0000\u0000\u0000\u0c4a\u0c4b\u0007"+ + "\u0006\u0000\u0000\u0c4b\u0c4c\u0007\u0005\u0000\u0000\u0c4c\u0c4d\u0007"+ + "\t\u0000\u0000\u0c4d\u0c4e\u0007\u0010\u0000\u0000\u0c4e\u01f2\u0001\u0000"+ + "\u0000\u0000\u0c4f\u0c50\u0007\u0006\u0000\u0000\u0c50\u0c51\u0007\n\u0000"+ + "\u0000\u0c51\u0c52\u0007\u0005\u0000\u0000\u0c52\u0c53\u0007\u0015\u0000"+ + "\u0000\u0c53\u0c54\u0007\u0018\u0000\u0000\u0c54\u0c55\u0007\r\u0000\u0000"+ + "\u0c55\u0c56\u0007\u0013\u0000\u0000\u0c56\u0c57\u0007\u0013\u0000\u0000"+ + "\u0c57\u0c58\u0007\u0019\u0000\u0000\u0c58\u01f4\u0001\u0000\u0000\u0000"+ + "\u0c59\u0c5a\u0007\u0006\u0000\u0000\u0c5a\u0c5b\u0007\n\u0000\u0000\u0c5b"+ + "\u0c5c\u0007\u001b\u0000\u0000\u0c5c\u0c5d\u0007\n\u0000\u0000\u0c5d\u0c5e"+ + "\u0007\u0006\u0000\u0000\u0c5e\u01f6\u0001\u0000\u0000\u0000\u0c5f\u0c60"+ + "\u0007\u0006\u0000\u0000\u0c60\u0c61\u0007\u0011\u0000\u0000\u0c61\u0c62"+ + "\u0007\t\u0000\u0000\u0c62\u0c63\u0007\u0010\u0000\u0000\u0c63\u0c64\u0007"+ + "\n\u0000\u0000\u0c64\u0c65\u0007\u0007\u0000\u0000\u0c65\u01f8\u0001\u0000"+ + "\u0000\u0000\u0c66\u0c67\u0007\u0006\u0000\u0000\u0c67\u0c68\u0007\u0013"+ + "\u0000\u0000\u0c68\u0c69\u0007\u0005\u0000\u0000\u0c69\u0c6a\u0007\f\u0000"+ + "\u0000\u0c6a\u01fa\u0001\u0000\u0000\u0000\u0c6b\u0c6c\u0007\u0006\u0000"+ + "\u0000\u0c6c\u0c6d\u0007\u0013\u0000\u0000\u0c6d\u0c6e\u0007\u000e\u0000"+ + "\u0000\u0c6e\u0c6f\u0007\u0005\u0000\u0000\u0c6f\u0c70\u0007\u0006\u0000"+ + "\u0000\u0c70\u01fc\u0001\u0000\u0000\u0000\u0c71\u0c72\u0007\u0006\u0000"+ + "\u0000\u0c72\u0c73\u0007\u0013\u0000\u0000\u0c73\u0c74\u0007\u000e\u0000"+ + "\u0000\u0c74\u0c75\u0007\u0005\u0000\u0000\u0c75\u0c76\u0007\u0010\u0000"+ + "\u0000\u0c76\u0c77\u0007\u0011\u0000\u0000\u0c77\u0c78\u0007\u0013\u0000"+ + "\u0000\u0c78\u0c79\u0007\u0007\u0000\u0000\u0c79\u01fe\u0001\u0000\u0000"+ + "\u0000\u0c7a\u0c7b\u0007\u0006\u0000\u0000\u0c7b\u0c7c\u0007\u0013\u0000"+ + "\u0000\u0c7c\u0c7d\u0007\u000e\u0000\u0000\u0c7d\u0c7e\u0007\u0015\u0000"+ + "\u0000\u0c7e\u0200\u0001\u0000\u0000\u0000\u0c7f\u0c80\u0007\u000f\u0000"+ + "\u0000\u0c80\u0c81\u0007\u0005\u0000\u0000\u0c81\u0c82\u0007\u0018\u0000"+ + "\u0000\u0c82\u0c83\u0007\u0018\u0000\u0000\u0c83\u0c84\u0007\u0011\u0000"+ + "\u0000\u0c84\u0c85\u0007\u0007\u0000\u0000\u0c85\u0c86\u0007\u0017\u0000"+ + "\u0000\u0c86\u0202\u0001\u0000\u0000\u0000\u0c87\u0c88\u0007\u000f\u0000"+ + "\u0000\u0c88\u0c89\u0007\u0005\u0000\u0000\u0c89\u0c8a\u0007\u0010\u0000"+ + "\u0000\u0c8a\u0c8b\u0007\u000e\u0000\u0000\u0c8b\u0c8c\u0007\u0014\u0000"+ + "\u0000\u0c8c\u0204\u0001\u0000\u0000\u0000\u0c8d\u0c8e\u0007\u000f\u0000"+ + "\u0000\u0c8e\u0c8f\u0007\u0005\u0000\u0000\u0c8f\u0c90\u0007\u0010\u0000"+ + "\u0000\u0c90\u0c91\u0007\u000e\u0000\u0000\u0c91\u0c92\u0007\u0014\u0000"+ + "\u0000\u0c92\u0c93\u0007\n\u0000\u0000\u0c93\u0c94\u0007\f\u0000\u0000"+ + "\u0c94\u0206\u0001\u0000\u0000\u0000\u0c95\u0c96\u0007\u000f\u0000\u0000"+ + "\u0c96\u0c97\u0007\u0005\u0000\u0000\u0c97\u0c98\u0007\u0010\u0000\u0000"+ + "\u0c98\u0c99\u0007\n\u0000\u0000\u0c99\u0c9a\u0007\r\u0000\u0000\u0c9a"+ + "\u0c9b\u0007\u0011\u0000\u0000\u0c9b\u0c9c\u0007\u0005\u0000\u0000\u0c9c"+ + "\u0c9d\u0007\u0006\u0000\u0000\u0c9d\u0c9e\u0007\u0011\u0000\u0000\u0c9e"+ + "\u0c9f\u0007\u000b\u0000\u0000\u0c9f\u0ca0\u0007\n\u0000\u0000\u0ca0\u0ca1"+ + "\u0007\f\u0000\u0000\u0ca1\u0208\u0001\u0000\u0000\u0000\u0ca2\u0ca3\u0007"+ + "\u000f\u0000\u0000\u0ca3\u0ca4\u0007\u0005\u0000\u0000\u0ca4\u0ca5\u0007"+ + "\u001a\u0000\u0000\u0ca5\u0ca6\u0007\u001b\u0000\u0000\u0ca6\u0ca7\u0007"+ + "\u0005\u0000\u0000\u0ca7\u0ca8\u0007\u0006\u0000\u0000\u0ca8\u0ca9\u0007"+ + "\u0016\u0000\u0000\u0ca9\u0caa\u0007\n\u0000\u0000\u0caa\u020a\u0001\u0000"+ + "\u0000\u0000\u0cab\u0cac\u0007\u000f\u0000\u0000\u0cac\u0cad\u0007\n\u0000"+ + "\u0000\u0cad\u0cae\u0007\r\u0000\u0000\u0cae\u0caf\u0007\u0017\u0000\u0000"+ + "\u0caf\u0cb0\u0007\n\u0000\u0000\u0cb0\u020c\u0001\u0000\u0000\u0000\u0cb1"+ + "\u0cb2\u0007\u000f\u0000\u0000\u0cb2\u0cb3\u0007\u0011\u0000\u0000\u0cb3"+ + "\u0cb4\u0007\u0007\u0000\u0000\u0cb4\u0cb5\u0007\u0016\u0000\u0000\u0cb5"+ + "\u0cb6\u0007\u0010\u0000\u0000\u0cb6\u0cb7\u0007\n\u0000\u0000\u0cb7\u020e"+ + "\u0001\u0000\u0000\u0000\u0cb8\u0cb9\u0007\u000f\u0000\u0000\u0cb9\u0cba"+ + "\u0007\u0011\u0000\u0000\u0cba\u0cbb\u0007\u0007\u0000\u0000\u0cbb\u0cbc"+ + "\u0007\u001b\u0000\u0000\u0cbc\u0cbd\u0007\u0005\u0000\u0000\u0cbd\u0cbe"+ + "\u0007\u0006\u0000\u0000\u0cbe\u0cbf\u0007\u0016\u0000\u0000\u0cbf\u0cc0"+ + "\u0007\n\u0000\u0000\u0cc0\u0210\u0001\u0000\u0000\u0000\u0cc1\u0cc2\u0007"+ + "\u000f\u0000\u0000\u0cc2\u0cc3\u0007\u0013\u0000\u0000\u0cc3\u0cc4\u0007"+ + "\f\u0000\u0000\u0cc4\u0cc5\u0007\n\u0000\u0000\u0cc5\u0212\u0001\u0000"+ + "\u0000\u0000\u0cc6\u0cc7\u0007\u000f\u0000\u0000\u0cc7\u0cc8\u0007\u0013"+ + "\u0000\u0000\u0cc8\u0cc9\u0007\u0007\u0000\u0000\u0cc9\u0cca\u0007\u0010"+ + "\u0000\u0000\u0cca\u0ccb\u0007\u0014\u0000\u0000\u0ccb\u0214\u0001\u0000"+ + "\u0000\u0000\u0ccc\u0ccd\u0007\u000f\u0000\u0000\u0ccd\u0cce\u0007\u0013"+ + "\u0000\u0000\u0cce\u0ccf\u0007\u001b\u0000\u0000\u0ccf\u0cd0\u0007\n\u0000"+ + "\u0000\u0cd0\u0216\u0001\u0000\u0000\u0000\u0cd1\u0cd2\u0007\u0007\u0000"+ + "\u0000\u0cd2\u0cd3\u0007\u0005\u0000\u0000\u0cd3\u0cd4\u0007\u000f\u0000"+ + "\u0000\u0cd4\u0cd5\u0007\n\u0000\u0000\u0cd5\u0218\u0001\u0000\u0000\u0000"+ + "\u0cd6\u0cd7\u0007\u0007\u0000\u0000\u0cd7\u0cd8\u0007\u0005\u0000\u0000"+ + "\u0cd8\u0cd9\u0007\u000f\u0000\u0000\u0cd9\u0cda\u0007\n\u0000\u0000\u0cda"+ + "\u0cdb\u0007\t\u0000\u0000\u0cdb\u021a\u0001\u0000\u0000\u0000\u0cdc\u0cdd"+ + "\u0007\u0007\u0000\u0000\u0cdd\u0cde\u0007\n\u0000\u0000\u0cde\u0cdf\u0007"+ + "\u001a\u0000\u0000\u0cdf\u0ce0\u0007\u0010\u0000\u0000\u0ce0\u021c\u0001"+ + "\u0000\u0000\u0000\u0ce1\u0ce2\u0007\u0007\u0000\u0000\u0ce2\u0ce3\u0007"+ + "\u0013\u0000\u0000\u0ce3\u021e\u0001\u0000\u0000\u0000\u0ce4\u0ce5\u0007"+ + "\u0007\u0000\u0000\u0ce5\u0ce6\u0007\u0013\u0000\u0000\u0ce6\u0ce7\u0007"+ + "\u0010\u0000\u0000\u0ce7\u0ce8\u0007\u0014\u0000\u0000\u0ce8\u0ce9\u0007"+ + "\u0011\u0000\u0000\u0ce9\u0cea\u0007\u0007\u0000\u0000\u0cea\u0ceb\u0007"+ + "\u0017\u0000\u0000\u0ceb\u0220\u0001\u0000\u0000\u0000\u0cec\u0ced\u0007"+ + "\u0007\u0000\u0000\u0ced\u0cee\u0007\u0013\u0000\u0000\u0cee\u0cef\u0007"+ + "\u0010\u0000\u0000\u0cef\u0cf0\u0007\u0011\u0000\u0000\u0cf0\u0cf1\u0007"+ + "\u0019\u0000\u0000\u0cf1\u0cf2\u0007\b\u0000\u0000\u0cf2\u0222\u0001\u0000"+ + "\u0000\u0000\u0cf3\u0cf4\u0007\u0007\u0000\u0000\u0cf4\u0cf5\u0007\u0013"+ + "\u0000\u0000\u0cf5\u0cf6\u0007\u001d\u0000\u0000\u0cf6\u0cf7\u0007\u0005"+ + "\u0000\u0000\u0cf7\u0cf8\u0007\u0011\u0000\u0000\u0cf8\u0cf9\u0007\u0010"+ + "\u0000\u0000\u0cf9\u0224\u0001\u0000\u0000\u0000\u0cfa\u0cfb\u0007\u0007"+ + "\u0000\u0000\u0cfb\u0cfc\u0007\u0016\u0000\u0000\u0cfc\u0cfd\u0007\u0006"+ + "\u0000\u0000\u0cfd\u0cfe\u0007\u0006\u0000\u0000\u0cfe\u0cff\u0007\t\u0000"+ + "\u0000\u0cff\u0226\u0001\u0000\u0000\u0000\u0d00\u0d01\u0007\u0013\u0000"+ + "\u0000\u0d01\u0d02\u0007\u0012\u0000\u0000\u0d02\u0d03\u0007\u001e\u0000"+ + "\u0000\u0d03\u0d04\u0007\n\u0000\u0000\u0d04\u0d05\u0007\u000e\u0000\u0000"+ + "\u0d05\u0d06\u0007\u0010\u0000\u0000\u0d06\u0228\u0001\u0000\u0000\u0000"+ + "\u0d07\u0d08\u0007\u0013\u0000\u0000\u0d08\u0d09\u0007\u0019\u0000\u0000"+ + "\u0d09\u022a\u0001\u0000\u0000\u0000\u0d0a\u0d0b\u0007\u0013\u0000\u0000"+ + "\u0d0b\u0d0c\u0007\u0019\u0000\u0000\u0d0c\u0d0d\u0007\u0019\u0000\u0000"+ + "\u0d0d\u022c\u0001\u0000\u0000\u0000\u0d0e\u0d0f\u0007\u0013\u0000\u0000"+ + "\u0d0f\u0d10\u0007\u0011\u0000\u0000\u0d10\u0d11\u0007\f\u0000\u0000\u0d11"+ + "\u0d12\u0007\t\u0000\u0000\u0d12\u022e\u0001\u0000\u0000\u0000\u0d13\u0d14"+ + "\u0007\u0013\u0000\u0000\u0d14\u0d15\u0007\u0018\u0000\u0000\u0d15\u0d16"+ + "\u0007\n\u0000\u0000\u0d16\u0d17\u0007\r\u0000\u0000\u0d17\u0d18\u0007"+ + "\u0005\u0000\u0000\u0d18\u0d19\u0007\u0010\u0000\u0000\u0d19\u0d1a\u0007"+ + "\u0013\u0000\u0000\u0d1a\u0d1b\u0007\r\u0000\u0000\u0d1b\u0230\u0001\u0000"+ + "\u0000\u0000\u0d1c\u0d1d\u0007\u0013\u0000\u0000\u0d1d\u0d1e\u0007\u0018"+ + "\u0000\u0000\u0d1e\u0d1f\u0007\u0010\u0000\u0000\u0d1f\u0d20\u0007\u0011"+ + "\u0000\u0000\u0d20\u0d21\u0007\u0013\u0000\u0000\u0d21\u0d22\u0007\u0007"+ + "\u0000\u0000\u0d22\u0232\u0001\u0000\u0000\u0000\u0d23\u0d24\u0007\u0013"+ + "\u0000\u0000\u0d24\u0d25\u0007\u0018\u0000\u0000\u0d25\u0d26\u0007\u0010"+ + "\u0000\u0000\u0d26\u0d27\u0007\u0011\u0000\u0000\u0d27\u0d28\u0007\u0013"+ + "\u0000\u0000\u0d28\u0d29\u0007\u0007\u0000\u0000\u0d29\u0d2a\u0007\t\u0000"+ + "\u0000\u0d2a\u0234\u0001\u0000\u0000\u0000\u0d2b\u0d2c\u0007\u0013\u0000"+ + "\u0000\u0d2c\u0d2d\u0007\u001d\u0000\u0000\u0d2d\u0d2e\u0007\u0007\u0000"+ + "\u0000\u0d2e\u0d2f\u0007\n\u0000\u0000\u0d2f\u0d30\u0007\f\u0000\u0000"+ + "\u0d30\u0236\u0001\u0000\u0000\u0000\u0d31\u0d32\u0007\u0013\u0000\u0000"+ + "\u0d32\u0d33\u0007\u001d\u0000\u0000\u0d33\u0d34\u0007\u0007\u0000\u0000"+ + "\u0d34\u0d35\u0007\n\u0000\u0000\u0d35\u0d36\u0007\r\u0000\u0000\u0d36"+ + "\u0238\u0001\u0000\u0000\u0000\u0d37\u0d38\u0007\u0018\u0000\u0000\u0d38"+ + "\u0d39\u0007\u0005\u0000\u0000\u0d39\u0d3a\u0007\r\u0000\u0000\u0d3a\u0d3b"+ + "\u0007\t\u0000\u0000\u0d3b\u0d3c\u0007\n\u0000\u0000\u0d3c\u0d3d\u0007"+ + "\r\u0000\u0000\u0d3d\u023a\u0001\u0000\u0000\u0000\u0d3e\u0d3f\u0007\u0018"+ + "\u0000\u0000\u0d3f\u0d40\u0007\u0005\u0000\u0000\u0d40\u0d41\u0007\r\u0000"+ + "\u0000\u0d41\u0d42\u0007\u0010\u0000\u0000\u0d42\u0d43\u0007\u0011\u0000"+ + "\u0000\u0d43\u0d44\u0007\u0005\u0000\u0000\u0d44\u0d45\u0007\u0006\u0000"+ + "\u0000\u0d45\u023c\u0001\u0000\u0000\u0000\u0d46\u0d47\u0007\u0018\u0000"+ + "\u0000\u0d47\u0d48\u0007\u0005\u0000\u0000\u0d48\u0d49\u0007\r\u0000\u0000"+ + "\u0d49\u0d4a\u0007\u0010\u0000\u0000\u0d4a\u0d4b\u0007\u0011\u0000\u0000"+ + "\u0d4b\u0d4c\u0007\u0010\u0000\u0000\u0d4c\u0d4d\u0007\u0011\u0000\u0000"+ + "\u0d4d\u0d4e\u0007\u0013\u0000\u0000\u0d4e\u0d4f\u0007\u0007\u0000\u0000"+ + "\u0d4f\u023e\u0001\u0000\u0000\u0000\u0d50\u0d51\u0007\u0018\u0000\u0000"+ + "\u0d51\u0d52\u0007\u0005\u0000\u0000\u0d52\u0d53\u0007\t\u0000\u0000\u0d53"+ + "\u0d54\u0007\t\u0000\u0000\u0d54\u0d55\u0007\u0011\u0000\u0000\u0d55\u0d56"+ + "\u0007\u0007\u0000\u0000\u0d56\u0d57\u0007\u0017\u0000\u0000\u0d57\u0240"+ + "\u0001\u0000\u0000\u0000\u0d58\u0d59\u0007\u0018\u0000\u0000\u0d59\u0d5a"+ + "\u0007\u0005\u0000\u0000\u0d5a\u0d5b\u0007\t\u0000\u0000\u0d5b\u0d5c\u0007"+ + "\t\u0000\u0000\u0d5c\u0d5d\u0007\u001d\u0000\u0000\u0d5d\u0d5e\u0007\u0013"+ + "\u0000\u0000\u0d5e\u0d5f\u0007\r\u0000\u0000\u0d5f\u0d60\u0007\f\u0000"+ + "\u0000\u0d60\u0242\u0001\u0000\u0000\u0000\u0d61\u0d62\u0007\u0018\u0000"+ + "\u0000\u0d62\u0d63\u0007\u0006\u0000\u0000\u0d63\u0d64\u0007\u0005\u0000"+ + "\u0000\u0d64\u0d65\u0007\u0007\u0000\u0000\u0d65\u0d66\u0007\t\u0000\u0000"+ + "\u0d66\u0244\u0001\u0000\u0000\u0000\u0d67\u0d68\u0007\u0018\u0000\u0000"+ + "\u0d68\u0d69\u0007\r\u0000\u0000\u0d69\u0d6a\u0007\n\u0000\u0000\u0d6a"+ + "\u0d6b\u0007\u000e\u0000\u0000\u0d6b\u0d6c\u0007\n\u0000\u0000\u0d6c\u0d6d"+ + "\u0007\f\u0000\u0000\u0d6d\u0d6e\u0007\u0011\u0000\u0000\u0d6e\u0d6f\u0007"+ + "\u0007\u0000\u0000\u0d6f\u0d70\u0007\u0017\u0000\u0000\u0d70\u0246\u0001"+ + "\u0000\u0000\u0000\u0d71\u0d72\u0007\u0018\u0000\u0000\u0d72\u0d73\u0007"+ + "\r\u0000\u0000\u0d73\u0d74\u0007\n\u0000\u0000\u0d74\u0d75\u0007\u0018"+ + "\u0000\u0000\u0d75\u0d76\u0007\u0005\u0000\u0000\u0d76\u0d77\u0007\r\u0000"+ + "\u0000\u0d77\u0d78\u0007\n\u0000\u0000\u0d78\u0248\u0001\u0000\u0000\u0000"+ + "\u0d79\u0d7a\u0007\u0018\u0000\u0000\u0d7a\u0d7b\u0007\r\u0000\u0000\u0d7b"+ + "\u0d7c\u0007\n\u0000\u0000\u0d7c\u0d7d\u0007\u0018\u0000\u0000\u0d7d\u0d7e"+ + "\u0007\u0005\u0000\u0000\u0d7e\u0d7f\u0007\r\u0000\u0000\u0d7f\u0d80\u0007"+ + "\n\u0000\u0000\u0d80\u0d81\u0007\f\u0000\u0000\u0d81\u024a\u0001\u0000"+ + "\u0000\u0000\u0d82\u0d83\u0007\u0018\u0000\u0000\u0d83\u0d84\u0007\r\u0000"+ + "\u0000\u0d84\u0d85\u0007\n\u0000\u0000\u0d85\u0d86\u0007\t\u0000\u0000"+ + "\u0d86\u0d87\u0007\n\u0000\u0000\u0d87\u0d88\u0007\r\u0000\u0000\u0d88"+ + "\u0d89\u0007\u001b\u0000\u0000\u0d89\u0d8a\u0007\n\u0000\u0000\u0d8a\u024c"+ + "\u0001\u0000\u0000\u0000\u0d8b\u0d8c\u0007\u0018\u0000\u0000\u0d8c\u0d8d"+ + "\u0007\r\u0000\u0000\u0d8d\u0d8e\u0007\u0011\u0000\u0000\u0d8e\u0d8f\u0007"+ + "\u0013\u0000\u0000\u0d8f\u0d90\u0007\r\u0000\u0000\u0d90\u024e\u0001\u0000"+ + "\u0000\u0000\u0d91\u0d92\u0007\u0018\u0000\u0000\u0d92\u0d93\u0007\r\u0000"+ + "\u0000\u0d93\u0d94\u0007\u0011\u0000\u0000\u0d94\u0d95\u0007\u001b\u0000"+ + "\u0000\u0d95\u0d96\u0007\u0011\u0000\u0000\u0d96\u0d97\u0007\u0006\u0000"+ + "\u0000\u0d97\u0d98\u0007\n\u0000\u0000\u0d98\u0d99\u0007\u0017\u0000\u0000"+ + "\u0d99\u0d9a\u0007\n\u0000\u0000\u0d9a\u0d9b\u0007\t\u0000\u0000\u0d9b"+ + "\u0250\u0001\u0000\u0000\u0000\u0d9c\u0d9d\u0007\u0018\u0000\u0000\u0d9d"+ + "\u0d9e\u0007\r\u0000\u0000\u0d9e\u0d9f\u0007\u0013\u0000\u0000\u0d9f\u0da0"+ + "\u0007\u000e\u0000\u0000\u0da0\u0da1\u0007\n\u0000\u0000\u0da1\u0da2\u0007"+ + "\f\u0000\u0000\u0da2\u0da3\u0007\u0016\u0000\u0000\u0da3\u0da4\u0007\r"+ + "\u0000\u0000\u0da4\u0da5\u0007\u0005\u0000\u0000\u0da5\u0da6\u0007\u0006"+ + "\u0000\u0000\u0da6\u0252\u0001\u0000\u0000\u0000\u0da7\u0da8\u0007\u0018"+ + "\u0000\u0000\u0da8\u0da9\u0007\r\u0000\u0000\u0da9\u0daa\u0007\u0013\u0000"+ + "\u0000\u0daa\u0dab\u0007\u000e\u0000\u0000\u0dab\u0dac\u0007\n\u0000\u0000"+ + "\u0dac\u0dad\u0007\f\u0000\u0000\u0dad\u0dae\u0007\u0016\u0000\u0000\u0dae"+ + "\u0daf\u0007\r\u0000\u0000\u0daf\u0db0\u0007\n\u0000\u0000\u0db0\u0254"+ + "\u0001\u0000\u0000\u0000\u0db1\u0db2\u0007\u0018\u0000\u0000\u0db2\u0db3"+ + "\u0007\r\u0000\u0000\u0db3\u0db4\u0007\u0013\u0000\u0000\u0db4\u0db5\u0007"+ + "\u0017\u0000\u0000\u0db5\u0db6\u0007\r\u0000\u0000\u0db6\u0db7\u0007\u0005"+ + "\u0000\u0000\u0db7\u0db8\u0007\u000f\u0000\u0000\u0db8\u0256\u0001\u0000"+ + "\u0000\u0000\u0db9\u0dba\u0007\u001c\u0000\u0000\u0dba\u0dbb\u0007\u0016"+ + "\u0000\u0000\u0dbb\u0dbc\u0007\u0013\u0000\u0000\u0dbc\u0dbd\u0007\u0010"+ + "\u0000\u0000\u0dbd\u0dbe\u0007\n\u0000\u0000\u0dbe\u0258\u0001\u0000\u0000"+ + "\u0000\u0dbf\u0dc0\u0007\r\u0000\u0000\u0dc0\u0dc1\u0007\u0005\u0000\u0000"+ + "\u0dc1\u0dc2\u0007\u0007\u0000\u0000\u0dc2\u0dc3\u0007\u0017\u0000\u0000"+ + "\u0dc3\u0dc4\u0007\n\u0000\u0000\u0dc4\u025a\u0001\u0000\u0000\u0000\u0dc5"+ + "\u0dc6\u0007\r\u0000\u0000\u0dc6\u0dc7\u0007\n\u0000\u0000\u0dc7\u0dc8"+ + "\u0007\u0005\u0000\u0000\u0dc8\u0dc9\u0007\f\u0000\u0000\u0dc9\u025c\u0001"+ + "\u0000\u0000\u0000\u0dca\u0dcb\u0007\r\u0000\u0000\u0dcb\u0dcc\u0007\n"+ + "\u0000\u0000\u0dcc\u0dcd\u0007\u0005\u0000\u0000\u0dcd\u0dce\u0007\t\u0000"+ + "\u0000\u0dce\u0dcf\u0007\t\u0000\u0000\u0dcf\u0dd0\u0007\u0011\u0000\u0000"+ + "\u0dd0\u0dd1\u0007\u0017\u0000\u0000\u0dd1\u0dd2\u0007\u0007\u0000\u0000"+ + "\u0dd2\u025e\u0001\u0000\u0000\u0000\u0dd3\u0dd4\u0007\r\u0000\u0000\u0dd4"+ + "\u0dd5\u0007\n\u0000\u0000\u0dd5\u0dd6\u0007\u000e\u0000\u0000\u0dd6\u0dd7"+ + "\u0007\u0014\u0000\u0000\u0dd7\u0dd8\u0007\n\u0000\u0000\u0dd8\u0dd9\u0007"+ + "\u000e\u0000\u0000\u0dd9\u0dda\u0007\u0015\u0000\u0000\u0dda\u0260\u0001"+ + "\u0000\u0000\u0000\u0ddb\u0ddc\u0007\r\u0000\u0000\u0ddc\u0ddd\u0007\n"+ + "\u0000\u0000\u0ddd\u0dde\u0007\u000e\u0000\u0000\u0dde\u0ddf\u0007\u0016"+ + "\u0000\u0000\u0ddf\u0de0\u0007\r\u0000\u0000\u0de0\u0de1\u0007\t\u0000"+ + "\u0000\u0de1\u0de2\u0007\u0011\u0000\u0000\u0de2\u0de3\u0007\u001b\u0000"+ + "\u0000\u0de3\u0de4\u0007\n\u0000\u0000\u0de4\u0262\u0001\u0000\u0000\u0000"+ + "\u0de5\u0de6\u0007\r\u0000\u0000\u0de6\u0de7\u0007\n\u0000\u0000\u0de7"+ + "\u0de8\u0007\u0019\u0000\u0000\u0de8\u0264\u0001\u0000\u0000\u0000\u0de9"+ + "\u0dea\u0007\r\u0000\u0000\u0dea\u0deb\u0007\n\u0000\u0000\u0deb\u0dec"+ + "\u0007\u0019\u0000\u0000\u0dec\u0ded\u0007\r\u0000\u0000\u0ded\u0dee\u0007"+ + "\n\u0000\u0000\u0dee\u0def\u0007\t\u0000\u0000\u0def\u0df0\u0007\u0014"+ + "\u0000\u0000\u0df0\u0266\u0001\u0000\u0000\u0000\u0df1\u0df2\u0007\r\u0000"+ + "\u0000\u0df2\u0df3\u0007\n\u0000\u0000\u0df3\u0df4\u0007\u0011\u0000\u0000"+ + "\u0df4\u0df5\u0007\u0007\u0000\u0000\u0df5\u0df6\u0007\f\u0000\u0000\u0df6"+ + "\u0df7\u0007\n\u0000\u0000\u0df7\u0df8\u0007\u001a\u0000\u0000\u0df8\u0268"+ + "\u0001\u0000\u0000\u0000\u0df9\u0dfa\u0007\r\u0000\u0000\u0dfa\u0dfb\u0007"+ + "\n\u0000\u0000\u0dfb\u0dfc\u0007\u0006\u0000\u0000\u0dfc\u0dfd\u0007\u0005"+ + "\u0000\u0000\u0dfd\u0dfe\u0007\u0010\u0000\u0000\u0dfe\u0dff\u0007\u0011"+ + "\u0000\u0000\u0dff\u0e00\u0007\u001b\u0000\u0000\u0e00\u0e01\u0007\n\u0000"+ + "\u0000\u0e01\u026a\u0001\u0000\u0000\u0000\u0e02\u0e03\u0007\r\u0000\u0000"+ + "\u0e03\u0e04\u0007\n\u0000\u0000\u0e04\u0e05\u0007\u0006\u0000\u0000\u0e05"+ + "\u0e06\u0007\n\u0000\u0000\u0e06\u0e07\u0007\u0005\u0000\u0000\u0e07\u0e08"+ + "\u0007\t\u0000\u0000\u0e08\u0e09\u0007\n\u0000\u0000\u0e09\u026c\u0001"+ + "\u0000\u0000\u0000\u0e0a\u0e0b\u0007\r\u0000\u0000\u0e0b\u0e0c\u0007\n"+ + "\u0000\u0000\u0e0c\u0e0d\u0007\u0007\u0000\u0000\u0e0d\u0e0e\u0007\u0005"+ + "\u0000\u0000\u0e0e\u0e0f\u0007\u000f\u0000\u0000\u0e0f\u0e10\u0007\n\u0000"+ + "\u0000\u0e10\u026e\u0001\u0000\u0000\u0000\u0e11\u0e12\u0007\r\u0000\u0000"+ + "\u0e12\u0e13\u0007\n\u0000\u0000\u0e13\u0e14\u0007\u0018\u0000\u0000\u0e14"+ + "\u0e15\u0007\n\u0000\u0000\u0e15\u0e16\u0007\u0005\u0000\u0000\u0e16\u0e17"+ + "\u0007\u0010\u0000\u0000\u0e17\u0e18\u0007\u0005\u0000\u0000\u0e18\u0e19"+ + "\u0007\u0012\u0000\u0000\u0e19\u0e1a\u0007\u0006\u0000\u0000\u0e1a\u0e1b"+ + "\u0007\n\u0000\u0000\u0e1b\u0270\u0001\u0000\u0000\u0000\u0e1c\u0e1d\u0007"+ + "\r\u0000\u0000\u0e1d\u0e1e\u0007\n\u0000\u0000\u0e1e\u0e1f\u0007\u0018"+ + "\u0000\u0000\u0e1f\u0e20\u0007\u0006\u0000\u0000\u0e20\u0e21\u0007\u0005"+ + "\u0000\u0000\u0e21\u0e22\u0007\u000e\u0000\u0000\u0e22\u0e23\u0007\n\u0000"+ + "\u0000\u0e23\u0272\u0001\u0000\u0000\u0000\u0e24\u0e25\u0007\r\u0000\u0000"+ + "\u0e25\u0e26\u0007\n\u0000\u0000\u0e26\u0e27\u0007\u0018\u0000\u0000\u0e27"+ + "\u0e28\u0007\u0006\u0000\u0000\u0e28\u0e29\u0007\u0011\u0000\u0000\u0e29"+ + "\u0e2a\u0007\u000e\u0000\u0000\u0e2a\u0e2b\u0007\u0005\u0000\u0000\u0e2b"+ + "\u0274\u0001\u0000\u0000\u0000\u0e2c\u0e2d\u0007\r\u0000\u0000\u0e2d\u0e2e"+ + "\u0007\n\u0000\u0000\u0e2e\u0e2f\u0007\t\u0000\u0000\u0e2f\u0e30\u0007"+ + "\n\u0000\u0000\u0e30\u0e31\u0007\u0010\u0000\u0000\u0e31\u0276\u0001\u0000"+ + "\u0000\u0000\u0e32\u0e33\u0007\r\u0000\u0000\u0e33\u0e34\u0007\n\u0000"+ + "\u0000\u0e34\u0e35\u0007\t\u0000\u0000\u0e35\u0e36\u0007\u0010\u0000\u0000"+ + "\u0e36\u0e37\u0007\u0005\u0000\u0000\u0e37\u0e38\u0007\r\u0000\u0000\u0e38"+ + "\u0e39\u0007\u0010\u0000\u0000\u0e39\u0278\u0001\u0000\u0000\u0000\u0e3a"+ + "\u0e3b\u0007\r\u0000\u0000\u0e3b\u0e3c\u0007\n\u0000\u0000\u0e3c\u0e3d"+ + "\u0007\t\u0000\u0000\u0e3d\u0e3e\u0007\u0010\u0000\u0000\u0e3e\u0e3f\u0007"+ + "\r\u0000\u0000\u0e3f\u0e40\u0007\u0011\u0000\u0000\u0e40\u0e41\u0007\u000e"+ + "\u0000\u0000\u0e41\u0e42\u0007\u0010\u0000\u0000\u0e42\u027a\u0001\u0000"+ + "\u0000\u0000\u0e43\u0e44\u0007\r\u0000\u0000\u0e44\u0e45\u0007\n\u0000"+ + "\u0000\u0e45\u0e46\u0007\u0010\u0000\u0000\u0e46\u0e47\u0007\u0016\u0000"+ + "\u0000\u0e47\u0e48\u0007\r\u0000\u0000\u0e48\u0e49\u0007\u0007\u0000\u0000"+ + "\u0e49\u0e4a\u0007\t\u0000\u0000\u0e4a\u027c\u0001\u0000\u0000\u0000\u0e4b"+ + "\u0e4c\u0007\r\u0000\u0000\u0e4c\u0e4d\u0007\n\u0000\u0000\u0e4d\u0e4e"+ + "\u0007\u001b\u0000\u0000\u0e4e\u0e4f\u0007\u0013\u0000\u0000\u0e4f\u0e50"+ + "\u0007\u0015\u0000\u0000\u0e50\u0e51\u0007\n\u0000\u0000\u0e51\u027e\u0001"+ + "\u0000\u0000\u0000\u0e52\u0e53\u0007\r\u0000\u0000\u0e53\u0e54\u0007\u0013"+ + "\u0000\u0000\u0e54\u0e55\u0007\u0006\u0000\u0000\u0e55\u0e56\u0007\n\u0000"+ + "\u0000\u0e56\u0280\u0001\u0000\u0000\u0000\u0e57\u0e58\u0007\r\u0000\u0000"+ + "\u0e58\u0e59\u0007\u0013\u0000\u0000\u0e59\u0e5a\u0007\u0006\u0000\u0000"+ + "\u0e5a\u0e5b\u0007\u0006\u0000\u0000\u0e5b\u0e5c\u0007\u0012\u0000\u0000"+ + "\u0e5c\u0e5d\u0007\u0005\u0000\u0000\u0e5d\u0e5e\u0007\u000e\u0000\u0000"+ + "\u0e5e\u0e5f\u0007\u0015\u0000\u0000\u0e5f\u0282\u0001\u0000\u0000\u0000"+ + "\u0e60\u0e61\u0007\r\u0000\u0000\u0e61\u0e62\u0007\u0013\u0000\u0000\u0e62"+ + "\u0e63\u0007\u001d\u0000\u0000\u0e63\u0e64\u0007\t\u0000\u0000\u0e64\u0284"+ + "\u0001\u0000\u0000\u0000\u0e65\u0e66\u0007\r\u0000\u0000\u0e66\u0e67\u0007"+ + "\u0016\u0000\u0000\u0e67\u0e68\u0007\u0006\u0000\u0000\u0e68\u0e69\u0007"+ + "\n\u0000\u0000\u0e69\u0286\u0001\u0000\u0000\u0000\u0e6a\u0e6b\u0007\t"+ + "\u0000\u0000\u0e6b\u0e6c\u0007\u0005\u0000\u0000\u0e6c\u0e6d\u0007\u001b"+ + "\u0000\u0000\u0e6d\u0e6e\u0007\n\u0000\u0000\u0e6e\u0e6f\u0007\u0018\u0000"+ + "\u0000\u0e6f\u0e70\u0007\u0013\u0000\u0000\u0e70\u0e71\u0007\u0011\u0000"+ + "\u0000\u0e71\u0e72\u0007\u0007\u0000\u0000\u0e72\u0e73\u0007\u0010\u0000"+ + "\u0000\u0e73\u0288\u0001\u0000\u0000\u0000\u0e74\u0e75\u0007\t\u0000\u0000"+ + "\u0e75\u0e76\u0007\u000e\u0000\u0000\u0e76\u0e77\u0007\u0014\u0000\u0000"+ + "\u0e77\u0e78\u0007\n\u0000\u0000\u0e78\u0e79\u0007\u000f\u0000\u0000\u0e79"+ + "\u0e7a\u0007\u0005\u0000\u0000\u0e7a\u028a\u0001\u0000\u0000\u0000\u0e7b"+ + "\u0e7c\u0007\t\u0000\u0000\u0e7c\u0e7d\u0007\u000e\u0000\u0000\u0e7d\u0e7e"+ + "\u0007\r\u0000\u0000\u0e7e\u0e7f\u0007\u0013\u0000\u0000\u0e7f\u0e80\u0007"+ + "\u0006\u0000\u0000\u0e80\u0e81\u0007\u0006\u0000\u0000\u0e81\u028c\u0001"+ + "\u0000\u0000\u0000\u0e82\u0e83\u0007\t\u0000\u0000\u0e83\u0e84\u0007\n"+ + "\u0000\u0000\u0e84\u0e85\u0007\u0005\u0000\u0000\u0e85\u0e86\u0007\r\u0000"+ + "\u0000\u0e86\u0e87\u0007\u000e\u0000\u0000\u0e87\u0e88\u0007\u0014\u0000"+ + "\u0000\u0e88\u028e\u0001\u0000\u0000\u0000\u0e89\u0e8a\u0007\t\u0000\u0000"+ + "\u0e8a\u0e8b\u0007\n\u0000\u0000\u0e8b\u0e8c\u0007\u000e\u0000\u0000\u0e8c"+ + "\u0e8d\u0007\u0013\u0000\u0000\u0e8d\u0e8e\u0007\u0007\u0000\u0000\u0e8e"+ + "\u0e8f\u0007\f\u0000\u0000\u0e8f\u0290\u0001\u0000\u0000\u0000\u0e90\u0e91"+ + "\u0007\t\u0000\u0000\u0e91\u0e92\u0007\n\u0000\u0000\u0e92\u0e93\u0007"+ + "\u000e\u0000\u0000\u0e93\u0e94\u0007\u0016\u0000\u0000\u0e94\u0e95\u0007"+ + "\r\u0000\u0000\u0e95\u0e96\u0007\u0011\u0000\u0000\u0e96\u0e97\u0007\u0010"+ + "\u0000\u0000\u0e97\u0e98\u0007\b\u0000\u0000\u0e98\u0292\u0001\u0000\u0000"+ + "\u0000\u0e99\u0e9a\u0007\t\u0000\u0000\u0e9a\u0e9b\u0007\n\u0000\u0000"+ + "\u0e9b\u0e9c\u0007\u001c\u0000\u0000\u0e9c\u0e9d\u0007\u0016\u0000\u0000"+ + "\u0e9d\u0e9e\u0007\n\u0000\u0000\u0e9e\u0e9f\u0007\u0007\u0000\u0000\u0e9f"+ + "\u0ea0\u0007\u000e\u0000\u0000\u0ea0\u0ea1\u0007\n\u0000\u0000\u0ea1\u0294"+ + "\u0001\u0000\u0000\u0000\u0ea2\u0ea3\u0007\t\u0000\u0000\u0ea3\u0ea4\u0007"+ + "\n\u0000\u0000\u0ea4\u0ea5\u0007\u001c\u0000\u0000\u0ea5\u0ea6\u0007\u0016"+ + "\u0000\u0000\u0ea6\u0ea7\u0007\n\u0000\u0000\u0ea7\u0ea8\u0007\u0007\u0000"+ + "\u0000\u0ea8\u0ea9\u0007\u000e\u0000\u0000\u0ea9\u0eaa\u0007\n\u0000\u0000"+ + "\u0eaa\u0eab\u0007\t\u0000\u0000\u0eab\u0296\u0001\u0000\u0000\u0000\u0eac"+ + "\u0ead\u0007\t\u0000\u0000\u0ead\u0eae\u0007\n\u0000\u0000\u0eae\u0eaf"+ + "\u0007\r\u0000\u0000\u0eaf\u0eb0\u0007\u0011\u0000\u0000\u0eb0\u0eb1\u0007"+ + "\u0005\u0000\u0000\u0eb1\u0eb2\u0007\u0006\u0000\u0000\u0eb2\u0eb3\u0007"+ + "\u0011\u0000\u0000\u0eb3\u0eb4\u0007\u000b\u0000\u0000\u0eb4\u0eb5\u0007"+ + "\u0005\u0000\u0000\u0eb5\u0eb6\u0007\u0012\u0000\u0000\u0eb6\u0eb7\u0007"+ + "\u0006\u0000\u0000\u0eb7\u0eb8\u0007\n\u0000\u0000\u0eb8\u0298\u0001\u0000"+ + "\u0000\u0000\u0eb9\u0eba\u0007\t\u0000\u0000\u0eba\u0ebb\u0007\n\u0000"+ + "\u0000\u0ebb\u0ebc\u0007\r\u0000\u0000\u0ebc\u0ebd\u0007\u001b\u0000\u0000"+ + "\u0ebd\u0ebe\u0007\n\u0000\u0000\u0ebe\u0ebf\u0007\r\u0000\u0000\u0ebf"+ + "\u029a\u0001\u0000\u0000\u0000\u0ec0\u0ec1\u0007\t\u0000\u0000\u0ec1\u0ec2"+ + "\u0007\n\u0000\u0000\u0ec2\u0ec3\u0007\t\u0000\u0000\u0ec3\u0ec4\u0007"+ + "\t\u0000\u0000\u0ec4\u0ec5\u0007\u0011\u0000\u0000\u0ec5\u0ec6\u0007\u0013"+ + "\u0000\u0000\u0ec6\u0ec7\u0007\u0007\u0000\u0000\u0ec7\u029c\u0001\u0000"+ + "\u0000\u0000\u0ec8\u0ec9\u0007\t\u0000\u0000\u0ec9\u0eca\u0007\n\u0000"+ + "\u0000\u0eca\u0ecb\u0007\u0010\u0000\u0000\u0ecb\u029e\u0001\u0000\u0000"+ + "\u0000\u0ecc\u0ecd\u0007\t\u0000\u0000\u0ecd\u0ece\u0007\u0014\u0000\u0000"+ + "\u0ece\u0ecf\u0007\u0005\u0000\u0000\u0ecf\u0ed0\u0007\r\u0000\u0000\u0ed0"+ + "\u0ed1\u0007\n\u0000\u0000\u0ed1\u02a0\u0001\u0000\u0000\u0000\u0ed2\u0ed3"+ + "\u0007\t\u0000\u0000\u0ed3\u0ed4\u0007\u0014\u0000\u0000\u0ed4\u0ed5\u0007"+ + "\u0013\u0000\u0000\u0ed5\u0ed6\u0007\u001d\u0000\u0000\u0ed6\u02a2\u0001"+ + "\u0000\u0000\u0000\u0ed7\u0ed8\u0007\t\u0000\u0000\u0ed8\u0ed9\u0007\u0011"+ + "\u0000\u0000\u0ed9\u0eda\u0007\u000f\u0000\u0000\u0eda\u0edb\u0007\u0018"+ + "\u0000\u0000\u0edb\u0edc\u0007\u0006\u0000\u0000\u0edc\u0edd\u0007\n\u0000"+ + "\u0000\u0edd\u02a4\u0001\u0000\u0000\u0000\u0ede\u0edf\u0007\t\u0000\u0000"+ + "\u0edf\u0ee0\u0007\u0007\u0000\u0000\u0ee0\u0ee1\u0007\u0005\u0000\u0000"+ + "\u0ee1\u0ee2\u0007\u0018\u0000\u0000\u0ee2\u0ee3\u0007\t\u0000\u0000\u0ee3"+ + "\u0ee4\u0007\u0014\u0000\u0000\u0ee4\u0ee5\u0007\u0013\u0000\u0000\u0ee5"+ + "\u0ee6\u0007\u0010\u0000\u0000\u0ee6\u02a6\u0001\u0000\u0000\u0000\u0ee7"+ + "\u0ee8\u0007\t\u0000\u0000\u0ee8\u0ee9\u0007\u0010\u0000\u0000\u0ee9\u0eea"+ + "\u0007\u0005\u0000\u0000\u0eea\u0eeb\u0007\u0012\u0000\u0000\u0eeb\u0eec"+ + "\u0007\u0006\u0000\u0000\u0eec\u0eed\u0007\n\u0000\u0000\u0eed\u02a8\u0001"+ + "\u0000\u0000\u0000\u0eee\u0eef\u0007\t\u0000\u0000\u0eef\u0ef0\u0007\u0010"+ + "\u0000\u0000\u0ef0\u0ef1\u0007\u0005\u0000\u0000\u0ef1\u0ef2\u0007\u0007"+ + "\u0000\u0000\u0ef2\u0ef3\u0007\f\u0000\u0000\u0ef3\u0ef4\u0007\u0005\u0000"+ + "\u0000\u0ef4\u0ef5\u0007\u0006\u0000\u0000\u0ef5\u0ef6\u0007\u0013\u0000"+ + "\u0000\u0ef6\u0ef7\u0007\u0007\u0000\u0000\u0ef7\u0ef8\u0007\n\u0000\u0000"+ + "\u0ef8\u02aa\u0001\u0000\u0000\u0000\u0ef9\u0efa\u0007\t\u0000\u0000\u0efa"+ + "\u0efb\u0007\u0010\u0000\u0000\u0efb\u0efc\u0007\u0005\u0000\u0000\u0efc"+ + "\u0efd\u0007\r\u0000\u0000\u0efd\u0efe\u0007\u0010\u0000\u0000\u0efe\u02ac"+ + "\u0001\u0000\u0000\u0000\u0eff\u0f00\u0007\t\u0000\u0000\u0f00\u0f01\u0007"+ + "\u0010\u0000\u0000\u0f01\u0f02\u0007\u0005\u0000\u0000\u0f02\u0f03\u0007"+ + "\u0010\u0000\u0000\u0f03\u0f04\u0007\n\u0000\u0000\u0f04\u0f05\u0007\u000f"+ + "\u0000\u0000\u0f05\u0f06\u0007\n\u0000\u0000\u0f06\u0f07\u0007\u0007\u0000"+ + "\u0000\u0f07\u0f08\u0007\u0010\u0000\u0000\u0f08\u02ae\u0001\u0000\u0000"+ + "\u0000\u0f09\u0f0a\u0007\t\u0000\u0000\u0f0a\u0f0b\u0007\u0010\u0000\u0000"+ + "\u0f0b\u0f0c\u0007\u0005\u0000\u0000\u0f0c\u0f0d\u0007\u0010\u0000\u0000"+ + "\u0f0d\u0f0e\u0007\u0011\u0000\u0000\u0f0e\u0f0f\u0007\t\u0000\u0000\u0f0f"+ + "\u0f10\u0007\u0010\u0000\u0000\u0f10\u0f11\u0007\u0011\u0000\u0000\u0f11"+ + "\u0f12\u0007\u000e\u0000\u0000\u0f12\u0f13\u0007\t\u0000\u0000\u0f13\u02b0"+ + "\u0001\u0000\u0000\u0000\u0f14\u0f15\u0007\t\u0000\u0000\u0f15\u0f16\u0007"+ + "\u0010\u0000\u0000\u0f16\u0f17\u0007\f\u0000\u0000\u0f17\u0f18\u0007\u0011"+ + "\u0000\u0000\u0f18\u0f19\u0007\u0007\u0000\u0000\u0f19\u02b2\u0001\u0000"+ + "\u0000\u0000\u0f1a\u0f1b\u0007\t\u0000\u0000\u0f1b\u0f1c\u0007\u0010\u0000"+ + "\u0000\u0f1c\u0f1d\u0007\f\u0000\u0000\u0f1d\u0f1e\u0007\u0013\u0000\u0000"+ + "\u0f1e\u0f1f\u0007\u0016\u0000\u0000\u0f1f\u0f20\u0007\u0010\u0000\u0000"+ + "\u0f20\u02b4\u0001\u0000\u0000\u0000\u0f21\u0f22\u0007\t\u0000\u0000\u0f22"+ + "\u0f23\u0007\u0010\u0000\u0000\u0f23\u0f24\u0007\u0013\u0000\u0000\u0f24"+ + "\u0f25\u0007\r\u0000\u0000\u0f25\u0f26\u0007\u0005\u0000\u0000\u0f26\u0f27"+ + "\u0007\u0017\u0000\u0000\u0f27\u0f28\u0007\n\u0000\u0000\u0f28\u02b6\u0001"+ + "\u0000\u0000\u0000\u0f29\u0f2a\u0007\t\u0000\u0000\u0f2a\u0f2b\u0007\u0010"+ + "\u0000\u0000\u0f2b\u0f2c\u0007\r\u0000\u0000\u0f2c\u0f2d\u0007\u0011\u0000"+ + "\u0000\u0f2d\u0f2e\u0007\u000e\u0000\u0000\u0f2e\u0f2f\u0007\u0010\u0000"+ + "\u0000\u0f2f\u02b8\u0001\u0000\u0000\u0000\u0f30\u0f31\u0007\t\u0000\u0000"+ + "\u0f31\u0f32\u0007\u0010\u0000\u0000\u0f32\u0f33\u0007\r\u0000\u0000\u0f33"+ + "\u0f34\u0007\u0011\u0000\u0000\u0f34\u0f35\u0007\u0018\u0000\u0000\u0f35"+ + "\u02ba\u0001\u0000\u0000\u0000\u0f36\u0f37\u0007\t\u0000\u0000\u0f37\u0f38"+ + "\u0007\b\u0000\u0000\u0f38\u0f39\u0007\t\u0000\u0000\u0f39\u0f3a\u0007"+ + "\u0011\u0000\u0000\u0f3a\u0f3b\u0007\f\u0000\u0000\u0f3b\u02bc\u0001\u0000"+ + "\u0000\u0000\u0f3c\u0f3d\u0007\t\u0000\u0000\u0f3d\u0f3e\u0007\b\u0000"+ + "\u0000\u0f3e\u0f3f\u0007\t\u0000\u0000\u0f3f\u0f40\u0007\u0010\u0000\u0000"+ + "\u0f40\u0f41\u0007\n\u0000\u0000\u0f41\u0f42\u0007\u000f\u0000\u0000\u0f42"+ + "\u02be\u0001\u0000\u0000\u0000\u0f43\u0f44\u0007\u0010\u0000\u0000\u0f44"+ + "\u0f45\u0007\u0005\u0000\u0000\u0f45\u0f46\u0007\u0012\u0000\u0000\u0f46"+ + "\u0f47\u0007\u0006\u0000\u0000\u0f47\u0f48\u0007\n\u0000\u0000\u0f48\u0f49"+ + "\u0007\t\u0000\u0000\u0f49\u02c0\u0001\u0000\u0000\u0000\u0f4a\u0f4b\u0007"+ + "\u0010\u0000\u0000\u0f4b\u0f4c\u0007\u0005\u0000\u0000\u0f4c\u0f4d\u0007"+ + "\u0012\u0000\u0000\u0f4d\u0f4e\u0007\u0006\u0000\u0000\u0f4e\u0f4f\u0007"+ + "\n\u0000\u0000\u0f4f\u0f50\u0007\t\u0000\u0000\u0f50\u0f51\u0007\u0018"+ + "\u0000\u0000\u0f51\u0f52\u0007\u0005\u0000\u0000\u0f52\u0f53\u0007\u000e"+ + "\u0000\u0000\u0f53\u0f54\u0007\n\u0000\u0000\u0f54\u02c2\u0001\u0000\u0000"+ + "\u0000\u0f55\u0f56\u0007\u0010\u0000\u0000\u0f56\u0f57\u0007\n\u0000\u0000"+ + "\u0f57\u0f58\u0007\u000f\u0000\u0000\u0f58\u0f59\u0007\u0018\u0000\u0000"+ + "\u0f59\u02c4\u0001\u0000\u0000\u0000\u0f5a\u0f5b\u0007\u0010\u0000\u0000"+ + "\u0f5b\u0f5c\u0007\n\u0000\u0000\u0f5c\u0f5d\u0007\u000f\u0000\u0000\u0f5d"+ + "\u0f5e\u0007\u0018\u0000\u0000\u0f5e\u0f5f\u0007\u0006\u0000\u0000\u0f5f"+ + "\u0f60\u0007\u0005\u0000\u0000\u0f60\u0f61\u0007\u0010\u0000\u0000\u0f61"+ + "\u0f62\u0007\n\u0000\u0000\u0f62\u02c6\u0001\u0000\u0000\u0000\u0f63\u0f64"+ + "\u0007\u0010\u0000\u0000\u0f64\u0f65\u0007\n\u0000\u0000\u0f65\u0f66\u0007"+ + "\u000f\u0000\u0000\u0f66\u0f67\u0007\u0018\u0000\u0000\u0f67\u0f68\u0007"+ + "\u0013\u0000\u0000\u0f68\u0f69\u0007\r\u0000\u0000\u0f69\u0f6a\u0007\u0005"+ + "\u0000\u0000\u0f6a\u0f6b\u0007\r\u0000\u0000\u0f6b\u0f6c\u0007\b\u0000"+ + "\u0000\u0f6c\u02c8\u0001\u0000\u0000\u0000\u0f6d\u0f6e\u0007\u0010\u0000"+ + "\u0000\u0f6e\u0f6f\u0007\n\u0000\u0000\u0f6f\u0f70\u0007\u001a\u0000\u0000"+ + "\u0f70\u0f71\u0007\u0010\u0000\u0000\u0f71\u02ca\u0001\u0000\u0000\u0000"+ + "\u0f72\u0f73\u0007\u0010\u0000\u0000\u0f73\u0f74\u0007\r\u0000\u0000\u0f74"+ + "\u0f75\u0007\u0005\u0000\u0000\u0f75\u0f76\u0007\u0007\u0000\u0000\u0f76"+ + "\u0f77\u0007\t\u0000\u0000\u0f77\u0f78\u0007\u0005\u0000\u0000\u0f78\u0f79"+ + "\u0007\u000e\u0000\u0000\u0f79\u0f7a\u0007\u0010\u0000\u0000\u0f7a\u0f7b"+ + "\u0007\u0011\u0000\u0000\u0f7b\u0f7c\u0007\u0013\u0000\u0000\u0f7c\u0f7d"+ + "\u0007\u0007\u0000\u0000\u0f7d\u02cc\u0001\u0000\u0000\u0000\u0f7e\u0f7f"+ + "\u0007\u0010\u0000\u0000\u0f7f\u0f80\u0007\r\u0000\u0000\u0f80\u0f81\u0007"+ + "\u0011\u0000\u0000\u0f81\u0f82\u0007\u0017\u0000\u0000\u0f82\u0f83\u0007"+ + "\u0017\u0000\u0000\u0f83\u0f84\u0007\n\u0000\u0000\u0f84\u0f85\u0007\r"+ + "\u0000\u0000\u0f85\u02ce\u0001\u0000\u0000\u0000\u0f86\u0f87\u0007\u0010"+ + "\u0000\u0000\u0f87\u0f88\u0007\r\u0000\u0000\u0f88\u0f89\u0007\u0016\u0000"+ + "\u0000\u0f89\u0f8a\u0007\u0007\u0000\u0000\u0f8a\u0f8b\u0007\u000e\u0000"+ + "\u0000\u0f8b\u0f8c\u0007\u0005\u0000\u0000\u0f8c\u0f8d\u0007\u0010\u0000"+ + "\u0000\u0f8d\u0f8e\u0007\n\u0000\u0000\u0f8e\u02d0\u0001\u0000\u0000\u0000"+ + "\u0f8f\u0f90\u0007\u0010\u0000\u0000\u0f90\u0f91\u0007\r\u0000\u0000\u0f91"+ + "\u0f92\u0007\u0016\u0000\u0000\u0f92\u0f93\u0007\t\u0000\u0000\u0f93\u0f94"+ + "\u0007\u0010\u0000\u0000\u0f94\u0f95\u0007\n\u0000\u0000\u0f95\u0f96\u0007"+ + "\f\u0000\u0000\u0f96\u02d2\u0001\u0000\u0000\u0000\u0f97\u0f98\u0007\u0010"+ + "\u0000\u0000\u0f98\u0f99\u0007\b\u0000\u0000\u0f99\u0f9a\u0007\u0018\u0000"+ + "\u0000\u0f9a\u0f9b\u0007\n\u0000\u0000\u0f9b\u02d4\u0001\u0000\u0000\u0000"+ + "\u0f9c\u0f9d\u0007\u0010\u0000\u0000\u0f9d\u0f9e\u0007\b\u0000\u0000\u0f9e"+ + "\u0f9f\u0007\u0018\u0000\u0000\u0f9f\u0fa0\u0007\n\u0000\u0000\u0fa0\u0fa1"+ + "\u0007\t\u0000\u0000\u0fa1\u02d6\u0001\u0000\u0000\u0000\u0fa2\u0fa3\u0007"+ + "\u0016\u0000\u0000\u0fa3\u0fa4\u0007\u0007\u0000\u0000\u0fa4\u0fa5\u0007"+ + "\u0012\u0000\u0000\u0fa5\u0fa6\u0007\u0013\u0000\u0000\u0fa6\u0fa7\u0007"+ + "\u0016\u0000\u0000\u0fa7\u0fa8\u0007\u0007\u0000\u0000\u0fa8\u0fa9\u0007"+ + "\f\u0000\u0000\u0fa9\u0faa\u0007\n\u0000\u0000\u0faa\u0fab\u0007\f\u0000"+ + "\u0000\u0fab\u02d8\u0001\u0000\u0000\u0000\u0fac\u0fad\u0007\u0016\u0000"+ + "\u0000\u0fad\u0fae\u0007\u0007\u0000\u0000\u0fae\u0faf\u0007\u000e\u0000"+ + "\u0000\u0faf\u0fb0\u0007\u0013\u0000\u0000\u0fb0\u0fb1\u0007\u000f\u0000"+ + "\u0000\u0fb1\u0fb2\u0007\u000f\u0000\u0000\u0fb2\u0fb3\u0007\u0011\u0000"+ + "\u0000\u0fb3\u0fb4\u0007\u0010\u0000\u0000\u0fb4\u0fb5\u0007\u0010\u0000"+ + "\u0000\u0fb5\u0fb6\u0007\n\u0000\u0000\u0fb6\u0fb7\u0007\f\u0000\u0000"+ + "\u0fb7\u02da\u0001\u0000\u0000\u0000\u0fb8\u0fb9\u0007\u0016\u0000\u0000"+ + "\u0fb9\u0fba\u0007\u0007\u0000\u0000\u0fba\u0fbb\u0007\n\u0000\u0000\u0fbb"+ + "\u0fbc\u0007\u0007\u0000\u0000\u0fbc\u0fbd\u0007\u000e\u0000\u0000\u0fbd"+ + "\u0fbe\u0007\r\u0000\u0000\u0fbe\u0fbf\u0007\b\u0000\u0000\u0fbf\u0fc0"+ + "\u0007\u0018\u0000\u0000\u0fc0\u0fc1\u0007\u0010\u0000\u0000\u0fc1\u0fc2"+ + "\u0007\n\u0000\u0000\u0fc2\u0fc3\u0007\f\u0000\u0000\u0fc3\u02dc\u0001"+ + "\u0000\u0000\u0000\u0fc4\u0fc5\u0007\u0016\u0000\u0000\u0fc5\u0fc6\u0007"+ + "\u0007\u0000\u0000\u0fc6\u0fc7\u0007\u0015\u0000\u0000\u0fc7\u0fc8\u0007"+ + "\u0007\u0000\u0000\u0fc8\u0fc9\u0007\u0013\u0000\u0000\u0fc9\u0fca\u0007"+ + "\u001d\u0000\u0000\u0fca\u0fcb\u0007\u0007\u0000\u0000\u0fcb\u02de\u0001"+ + "\u0000\u0000\u0000\u0fcc\u0fcd\u0007\u0016\u0000\u0000\u0fcd\u0fce\u0007"+ + "\u0007\u0000\u0000\u0fce\u0fcf\u0007\u0006\u0000\u0000\u0fcf\u0fd0\u0007"+ + "\u0011\u0000\u0000\u0fd0\u0fd1\u0007\t\u0000\u0000\u0fd1\u0fd2\u0007\u0010"+ + "\u0000\u0000\u0fd2\u0fd3\u0007\n\u0000\u0000\u0fd3\u0fd4\u0007\u0007\u0000"+ + "\u0000\u0fd4\u02e0\u0001\u0000\u0000\u0000\u0fd5\u0fd6\u0007\u0016\u0000"+ + "\u0000\u0fd6\u0fd7\u0007\u0007\u0000\u0000\u0fd7\u0fd8\u0007\u0006\u0000"+ + "\u0000\u0fd8\u0fd9\u0007\u0013\u0000\u0000\u0fd9\u0fda\u0007\u0017\u0000"+ + "\u0000\u0fda\u0fdb\u0007\u0017\u0000\u0000\u0fdb\u0fdc\u0007\n\u0000\u0000"+ + "\u0fdc\u0fdd\u0007\f\u0000\u0000\u0fdd\u02e2\u0001\u0000\u0000\u0000\u0fde"+ + "\u0fdf\u0007\u0016\u0000\u0000\u0fdf\u0fe0\u0007\u0007\u0000\u0000\u0fe0"+ + "\u0fe1\u0007\u0010\u0000\u0000\u0fe1\u0fe2\u0007\u0011\u0000\u0000\u0fe2"+ + "\u0fe3\u0007\u0006\u0000\u0000\u0fe3\u02e4\u0001\u0000\u0000\u0000\u0fe4"+ + "\u0fe5\u0007\u0016\u0000\u0000\u0fe5\u0fe6\u0007\u0018\u0000\u0000\u0fe6"+ + "\u0fe7\u0007\f\u0000\u0000\u0fe7\u0fe8\u0007\u0005\u0000\u0000\u0fe8\u0fe9"+ + "\u0007\u0010\u0000\u0000\u0fe9\u0fea\u0007\n\u0000\u0000\u0fea\u02e6\u0001"+ + "\u0000\u0000\u0000\u0feb\u0fec\u0007\u001b\u0000\u0000\u0fec\u0fed\u0007"+ + "\u0005\u0000\u0000\u0fed\u0fee\u0007\u000e\u0000\u0000\u0fee\u0fef\u0007"+ + "\u0016\u0000\u0000\u0fef\u0ff0\u0007\u0016\u0000\u0000\u0ff0\u0ff1\u0007"+ + "\u000f\u0000\u0000\u0ff1\u02e8\u0001\u0000\u0000\u0000\u0ff2\u0ff3\u0007"+ + "\u001b\u0000\u0000\u0ff3\u0ff4\u0007\u0005\u0000\u0000\u0ff4\u0ff5\u0007"+ + "\u0006\u0000\u0000\u0ff5\u0ff6\u0007\u0011\u0000\u0000\u0ff6\u0ff7\u0007"+ + "\f\u0000\u0000\u0ff7\u02ea\u0001\u0000\u0000\u0000\u0ff8\u0ff9\u0007\u001b"+ + "\u0000\u0000\u0ff9\u0ffa\u0007\u0005\u0000\u0000\u0ffa\u0ffb\u0007\u0006"+ + "\u0000\u0000\u0ffb\u0ffc\u0007\u0011\u0000\u0000\u0ffc\u0ffd\u0007\f\u0000"+ + "\u0000\u0ffd\u0ffe\u0007\u0005\u0000\u0000\u0ffe\u0fff\u0007\u0010\u0000"+ + "\u0000\u0fff\u1000\u0007\n\u0000\u0000\u1000\u02ec\u0001\u0000\u0000\u0000"+ + "\u1001\u1002\u0007\u001b\u0000\u0000\u1002\u1003\u0007\u0005\u0000\u0000"+ + "\u1003\u1004\u0007\u0006\u0000\u0000\u1004\u1005\u0007\u0011\u0000\u0000"+ + "\u1005\u1006\u0007\f\u0000\u0000\u1006\u1007\u0007\u0005\u0000\u0000\u1007"+ + "\u1008\u0007\u0010\u0000\u0000\u1008\u1009\u0007\u0013\u0000\u0000\u1009"+ + "\u100a\u0007\r\u0000\u0000\u100a\u02ee\u0001\u0000\u0000\u0000\u100b\u100c"+ + "\u0007\u001b\u0000\u0000\u100c\u100d\u0007\u0005\u0000\u0000\u100d\u100e"+ + "\u0007\r\u0000\u0000\u100e\u100f\u0007\b\u0000\u0000\u100f\u1010\u0007"+ + "\u0011\u0000\u0000\u1010\u1011\u0007\u0007\u0000\u0000\u1011\u1012\u0007"+ + "\u0017\u0000\u0000\u1012\u02f0\u0001\u0000\u0000\u0000\u1013\u1014\u0007"+ + "\u001b\u0000\u0000\u1014\u1015\u0007\n\u0000\u0000\u1015\u1016\u0007\r"+ + "\u0000\u0000\u1016\u1017\u0007\t\u0000\u0000\u1017\u1018\u0007\u0011\u0000"+ + "\u0000\u1018\u1019\u0007\u0013\u0000\u0000\u1019\u101a\u0007\u0007\u0000"+ + "\u0000\u101a\u02f2\u0001\u0000\u0000\u0000\u101b\u101c\u0007\u001b\u0000"+ + "\u0000\u101c\u101d\u0007\u0011\u0000\u0000\u101d\u101e\u0007\n\u0000\u0000"+ + "\u101e\u101f\u0007\u001d\u0000\u0000\u101f\u02f4\u0001\u0000\u0000\u0000"+ + "\u1020\u1021\u0007\u001b\u0000\u0000\u1021\u1022\u0007\u0013\u0000\u0000"+ + "\u1022\u1023\u0007\u0006\u0000\u0000\u1023\u1024\u0007\u0005\u0000\u0000"+ + "\u1024\u1025\u0007\u0010\u0000\u0000\u1025\u1026\u0007\u0011\u0000\u0000"+ + "\u1026\u1027\u0007\u0006\u0000\u0000\u1027\u1028\u0007\n\u0000\u0000\u1028"+ + "\u02f6\u0001\u0000\u0000\u0000\u1029\u102a\u0007\u001d\u0000\u0000\u102a"+ + "\u102b\u0007\u0014\u0000\u0000\u102b\u102c\u0007\u0011\u0000\u0000\u102c"+ + "\u102d\u0007\u0010\u0000\u0000\u102d\u102e\u0007\n\u0000\u0000\u102e\u102f"+ + "\u0007\t\u0000\u0000\u102f\u1030\u0007\u0018\u0000\u0000\u1030\u1031\u0007"+ + "\u0005\u0000\u0000\u1031\u1032\u0007\u000e\u0000\u0000\u1032\u1033\u0007"+ + "\n\u0000\u0000\u1033\u02f8\u0001\u0000\u0000\u0000\u1034\u1035\u0007\u001d"+ + "\u0000\u0000\u1035\u1036\u0007\u0011\u0000\u0000\u1036\u1037\u0007\u0010"+ + "\u0000\u0000\u1037\u1038\u0007\u0014\u0000\u0000\u1038\u1039\u0007\u0013"+ + "\u0000\u0000\u1039\u103a\u0007\u0016\u0000\u0000\u103a\u103b\u0007\u0010"+ + "\u0000\u0000\u103b\u02fa\u0001\u0000\u0000\u0000\u103c\u103d\u0007\u001d"+ + "\u0000\u0000\u103d\u103e\u0007\u0013\u0000\u0000\u103e\u103f\u0007\r\u0000"+ + "\u0000\u103f\u1040\u0007\u0015\u0000\u0000\u1040\u02fc\u0001\u0000\u0000"+ + "\u0000\u1041\u1042\u0007\u001d\u0000\u0000\u1042\u1043\u0007\r\u0000\u0000"+ + "\u1043\u1044\u0007\u0005\u0000\u0000\u1044\u1045\u0007\u0018\u0000\u0000"+ + "\u1045\u1046\u0007\u0018\u0000\u0000\u1046\u1047\u0007\n\u0000\u0000\u1047"+ + "\u1048\u0007\r\u0000\u0000\u1048\u02fe\u0001\u0000\u0000\u0000\u1049\u104a"+ + "\u0007\u001d\u0000\u0000\u104a\u104b\u0007\r\u0000\u0000\u104b\u104c\u0007"+ + "\u0011\u0000\u0000\u104c\u104d\u0007\u0010\u0000\u0000\u104d\u104e\u0007"+ + "\n\u0000\u0000\u104e\u0300\u0001\u0000\u0000\u0000\u104f\u1050\u0007\u001a"+ + "\u0000\u0000\u1050\u1051\u0007\u000f\u0000\u0000\u1051\u1052\u0007\u0006"+ + "\u0000\u0000\u1052\u0302\u0001\u0000\u0000\u0000\u1053\u1054\u0007\b\u0000"+ + "\u0000\u1054\u1055\u0007\n\u0000\u0000\u1055\u1056\u0007\u0005\u0000\u0000"+ + "\u1056\u1057\u0007\r\u0000\u0000\u1057\u0304\u0001\u0000\u0000\u0000\u1058"+ + "\u1059\u0007\b\u0000\u0000\u1059\u105a\u0007\n\u0000\u0000\u105a\u105b"+ + "\u0007\t\u0000\u0000\u105b\u0306\u0001\u0000\u0000\u0000\u105c\u105d\u0007"+ + "\u000b\u0000\u0000\u105d\u105e\u0007\u0013\u0000\u0000\u105e\u105f\u0007"+ + "\u0007\u0000\u0000\u105f\u1060\u0007\n\u0000\u0000\u1060\u0308\u0001\u0000"+ + "\u0000\u0000\u1061\u1062\u0007\u0012\u0000\u0000\u1062\u1063\u0007\n\u0000"+ + "\u0000\u1063\u1064\u0007\u0010\u0000\u0000\u1064\u1065\u0007\u001d\u0000"+ + "\u0000\u1065\u1066\u0007\n\u0000\u0000\u1066\u1067\u0007\n\u0000\u0000"+ + "\u1067\u1068\u0007\u0007\u0000\u0000\u1068\u030a\u0001\u0000\u0000\u0000"+ + "\u1069\u106a\u0007\u0012\u0000\u0000\u106a\u106b\u0007\u0011\u0000\u0000"+ + "\u106b\u106c\u0007\u0017\u0000\u0000\u106c\u106d\u0007\u0011\u0000\u0000"+ + "\u106d\u106e\u0007\u0007\u0000\u0000\u106e\u106f\u0007\u0010\u0000\u0000"+ + "\u106f\u030c\u0001\u0000\u0000\u0000\u1070\u1071\u0007\u0012\u0000\u0000"+ + "\u1071\u1072\u0007\u0011\u0000\u0000\u1072\u1073\u0007\u0010\u0000\u0000"+ + "\u1073\u030e\u0001\u0000\u0000\u0000\u1074\u1075\u0007\u0012\u0000\u0000"+ + "\u1075\u1076\u0007\u0013\u0000\u0000\u1076\u1077\u0007\u0013\u0000\u0000"+ + "\u1077\u1078\u0007\u0006\u0000\u0000\u1078\u1079\u0007\n\u0000\u0000\u1079"+ + "\u107a\u0007\u0005\u0000\u0000\u107a\u107b\u0007\u0007\u0000\u0000\u107b"+ + "\u0310\u0001\u0000\u0000\u0000\u107c\u107d\u0007\u000e\u0000\u0000\u107d"+ + "\u107e\u0007\u0014\u0000\u0000\u107e\u107f\u0007\u0005\u0000\u0000\u107f"+ + "\u1080\u0007\r\u0000\u0000\u1080\u0312\u0001\u0000\u0000\u0000\u1081\u1082"+ + "\u0007\u000e\u0000\u0000\u1082\u1083\u0007\u0014\u0000\u0000\u1083\u1084"+ + "\u0007\u0005\u0000\u0000\u1084\u1085\u0007\r\u0000\u0000\u1085\u1086\u0007"+ + "\u0005\u0000\u0000\u1086\u1087\u0007\u000e\u0000\u0000\u1087\u1088\u0007"+ + "\u0010\u0000\u0000\u1088\u1089\u0007\n\u0000\u0000\u1089\u108a\u0007\r"+ + "\u0000\u0000\u108a\u0314\u0001\u0000\u0000\u0000\u108b\u108c\u0007\u000e"+ + "\u0000\u0000\u108c\u108d\u0007\u0013\u0000\u0000\u108d\u108e\u0007\u0005"+ + "\u0000\u0000\u108e\u108f\u0007\u0006\u0000\u0000\u108f\u1090\u0007\n\u0000"+ + "\u0000\u1090\u1091\u0007\t\u0000\u0000\u1091\u1092\u0007\u000e\u0000\u0000"+ + "\u1092\u1093\u0007\n\u0000\u0000\u1093\u0316\u0001\u0000\u0000\u0000\u1094"+ + "\u1095\u0007\f\u0000\u0000\u1095\u1096\u0007\n\u0000\u0000\u1096\u1097"+ + "\u0007\u000e\u0000\u0000\u1097\u0318\u0001\u0000\u0000\u0000\u1098\u1099"+ + "\u0007\f\u0000\u0000\u1099\u109a\u0007\n\u0000\u0000\u109a\u109b\u0007"+ + "\u000e\u0000\u0000\u109b\u109c\u0007\u0011\u0000\u0000\u109c\u109d\u0007"+ + "\u000f\u0000\u0000\u109d\u109e\u0007\u0005\u0000\u0000\u109e\u109f\u0007"+ + "\u0006\u0000\u0000\u109f\u031a\u0001\u0000\u0000\u0000\u10a0\u10a1\u0007"+ + "\n\u0000\u0000\u10a1\u10a2\u0007\u001a\u0000\u0000\u10a2\u10a3\u0007\u0011"+ + "\u0000\u0000\u10a3\u10a4\u0007\t\u0000\u0000\u10a4\u10a5\u0007\u0010\u0000"+ + "\u0000\u10a5\u10a6\u0007\t\u0000\u0000\u10a6\u031c\u0001\u0000\u0000\u0000"+ + "\u10a7\u10a8\u0007\n\u0000\u0000\u10a8\u10a9\u0007\u001a\u0000\u0000\u10a9"+ + "\u10aa\u0007\u0010\u0000\u0000\u10aa\u10ab\u0007\r\u0000\u0000\u10ab\u10ac"+ + "\u0007\u0005\u0000\u0000\u10ac\u10ad\u0007\u000e\u0000\u0000\u10ad\u10ae"+ + "\u0007\u0010\u0000\u0000\u10ae\u031e\u0001\u0000\u0000\u0000\u10af\u10b0"+ + "\u0007\u0019\u0000\u0000\u10b0\u10b1\u0007\u0006\u0000\u0000\u10b1\u10b2"+ + "\u0007\u0013\u0000\u0000\u10b2\u10b3\u0007\u0005\u0000\u0000\u10b3\u10b4"+ + "\u0007\u0010\u0000\u0000\u10b4\u0320\u0001\u0000\u0000\u0000\u10b5\u10b6"+ + "\u0007\u0017\u0000\u0000\u10b6\u10b7\u0007\r\u0000\u0000\u10b7\u10b8\u0007"+ + "\n\u0000\u0000\u10b8\u10b9\u0007\u0005\u0000\u0000\u10b9\u10ba\u0007\u0010"+ + "\u0000\u0000\u10ba\u10bb\u0007\n\u0000\u0000\u10bb\u10bc\u0007\t\u0000"+ + "\u0000\u10bc\u10bd\u0007\u0010\u0000\u0000\u10bd\u0322\u0001\u0000\u0000"+ + "\u0000\u10be\u10bf\u0007\u0011\u0000\u0000\u10bf\u10c0\u0007\u0007\u0000"+ + "\u0000\u10c0\u10c1\u0007\u0013\u0000\u0000\u10c1\u10c2\u0007\u0016\u0000"+ + "\u0000\u10c2\u10c3\u0007\u0010\u0000\u0000\u10c3\u0324\u0001\u0000\u0000"+ + "\u0000\u10c4\u10c5\u0007\u0011\u0000\u0000\u10c5\u10c6\u0007\u0007\u0000"+ + "\u0000\u10c6\u10c7\u0007\u0010\u0000\u0000\u10c7\u0326\u0001\u0000\u0000"+ + "\u0000\u10c8\u10c9\u0007\u0011\u0000\u0000\u10c9\u10ca\u0007\u0007\u0000"+ + "\u0000\u10ca\u10cb\u0007\u0010\u0000\u0000\u10cb\u10cc\u0007\n\u0000\u0000"+ + "\u10cc\u10cd\u0007\u0017\u0000\u0000\u10cd\u10ce\u0007\n\u0000\u0000\u10ce"+ + "\u10cf\u0007\r\u0000\u0000\u10cf\u0328\u0001\u0000\u0000\u0000\u10d0\u10d1"+ + "\u0007\u0011\u0000\u0000\u10d1\u10d2\u0007\u0007\u0000\u0000\u10d2\u10d3"+ + "\u0007\u0010\u0000\u0000\u10d3\u10d4\u0007\n\u0000\u0000\u10d4\u10d5\u0007"+ + "\r\u0000\u0000\u10d5\u10d6\u0007\u001b\u0000\u0000\u10d6\u10d7\u0007\u0005"+ + "\u0000\u0000\u10d7\u10d8\u0007\u0006\u0000\u0000\u10d8\u032a\u0001\u0000"+ + "\u0000\u0000\u10d9\u10da\u0007\u0006\u0000\u0000\u10da\u10db\u0007\n\u0000"+ + "\u0000\u10db\u10dc\u0007\u0005\u0000\u0000\u10dc\u10dd\u0007\t\u0000\u0000"+ + "\u10dd\u10de\u0007\u0010\u0000\u0000\u10de\u032c\u0001\u0000\u0000\u0000"+ + "\u10df\u10e0\u0007\u0007\u0000\u0000\u10e0\u10e1\u0007\u0005\u0000\u0000"+ + "\u10e1\u10e2\u0007\u0010\u0000\u0000\u10e2\u10e3\u0007\u0011\u0000\u0000"+ + "\u10e3\u10e4\u0007\u0013\u0000\u0000\u10e4\u10e5\u0007\u0007\u0000\u0000"+ + "\u10e5\u10e6\u0007\u0005\u0000\u0000\u10e6\u10e7\u0007\u0006\u0000\u0000"+ + "\u10e7\u032e\u0001\u0000\u0000\u0000\u10e8\u10e9\u0007\u0007\u0000\u0000"+ + "\u10e9\u10ea\u0007\u000e\u0000\u0000\u10ea\u10eb\u0007\u0014\u0000\u0000"+ + "\u10eb\u10ec\u0007\u0005\u0000\u0000\u10ec\u10ed\u0007\r\u0000\u0000\u10ed"+ + "\u0330\u0001\u0000\u0000\u0000\u10ee\u10ef\u0007\u0007\u0000\u0000\u10ef"+ + "\u10f0\u0007\u0013\u0000\u0000\u10f0\u10f1\u0007\u0007\u0000\u0000\u10f1"+ + "\u10f2\u0007\n\u0000\u0000\u10f2\u0332\u0001\u0000\u0000\u0000\u10f3\u10f4"+ + "\u0007\u0007\u0000\u0000\u10f4\u10f5\u0007\u0016\u0000\u0000\u10f5\u10f6"+ + "\u0007\u0006\u0000\u0000\u10f6\u10f7\u0007\u0006\u0000\u0000\u10f7\u10f8"+ + "\u0007\u0011\u0000\u0000\u10f8\u10f9\u0007\u0019\u0000\u0000\u10f9\u0334"+ + "\u0001\u0000\u0000\u0000\u10fa\u10fb\u0007\u0007\u0000\u0000\u10fb\u10fc"+ + "\u0007\u0016\u0000\u0000\u10fc\u10fd\u0007\u000f\u0000\u0000\u10fd\u10fe"+ + "\u0007\n\u0000\u0000\u10fe\u10ff\u0007\r\u0000\u0000\u10ff\u1100\u0007"+ + "\u0011\u0000\u0000\u1100\u1101\u0007\u000e\u0000\u0000\u1101\u0336\u0001"+ + "\u0000\u0000\u0000\u1102\u1103\u0007\u0013\u0000\u0000\u1103\u1104\u0007"+ + "\u001b\u0000\u0000\u1104\u1105\u0007\n\u0000\u0000\u1105\u1106\u0007\r"+ + "\u0000\u0000\u1106\u1107\u0007\u0006\u0000\u0000\u1107\u1108\u0007\u0005"+ + "\u0000\u0000\u1108\u1109\u0007\b\u0000\u0000\u1109\u0338\u0001\u0000\u0000"+ + "\u0000\u110a\u110b\u0007\u0018\u0000\u0000\u110b\u110c\u0007\u0013\u0000"+ + "\u0000\u110c\u110d\u0007\t\u0000\u0000\u110d\u110e\u0007\u0011\u0000\u0000"+ + "\u110e\u110f\u0007\u0010\u0000\u0000\u110f\u1110\u0007\u0011\u0000\u0000"+ + "\u1110\u1111\u0007\u0013\u0000\u0000\u1111\u1112\u0007\u0007\u0000\u0000"+ + "\u1112\u033a\u0001\u0000\u0000\u0000\u1113\u1114\u0007\u0018\u0000\u0000"+ + "\u1114\u1115\u0007\r\u0000\u0000\u1115\u1116\u0007\n\u0000\u0000\u1116"+ + "\u1117\u0007\u000e\u0000\u0000\u1117\u1118\u0007\u0011\u0000\u0000\u1118"+ + "\u1119\u0007\t\u0000\u0000\u1119\u111a\u0007\u0011\u0000\u0000\u111a\u111b"+ + "\u0007\u0013\u0000\u0000\u111b\u111c\u0007\u0007\u0000\u0000\u111c\u033c"+ + "\u0001\u0000\u0000\u0000\u111d\u111e\u0007\r\u0000\u0000\u111e\u111f\u0007"+ + "\n\u0000\u0000\u111f\u1120\u0007\u0005\u0000\u0000\u1120\u1121\u0007\u0006"+ + "\u0000\u0000\u1121\u033e\u0001\u0000\u0000\u0000\u1122\u1123\u0007\r\u0000"+ + "\u0000\u1123\u1124\u0007\u0013\u0000\u0000\u1124\u1125\u0007\u001d\u0000"+ + "\u0000\u1125\u0340\u0001\u0000\u0000\u0000\u1126\u1127\u0007\t\u0000\u0000"+ + "\u1127\u1128\u0007\n\u0000\u0000\u1128\u1129\u0007\u0010\u0000\u0000\u1129"+ + "\u112a\u0007\u0013\u0000\u0000\u112a\u112b\u0007\u0019\u0000\u0000\u112b"+ + "\u0342\u0001\u0000\u0000\u0000\u112c\u112d\u0007\t\u0000\u0000\u112d\u112e"+ + "\u0007\u000f\u0000\u0000\u112e\u112f\u0007\u0005\u0000\u0000\u112f\u1130"+ + "\u0007\u0006\u0000\u0000\u1130\u1131\u0007\u0006\u0000\u0000\u1131\u1132"+ + "\u0007\u0011\u0000\u0000\u1132\u1133\u0007\u0007\u0000\u0000\u1133\u1134"+ + "\u0007\u0010\u0000\u0000\u1134\u0344\u0001\u0000\u0000\u0000\u1135\u1136"+ + "\u0007\t\u0000\u0000\u1136\u1137\u0007\u0016\u0000\u0000\u1137\u1138\u0007"+ + "\u0012\u0000\u0000\u1138\u1139\u0007\t\u0000\u0000\u1139\u113a\u0007\u0010"+ + "\u0000\u0000\u113a\u113b\u0007\r\u0000\u0000\u113b\u113c\u0007\u0011\u0000"+ + "\u0000\u113c\u113d\u0007\u0007\u0000\u0000\u113d\u113e\u0007\u0017\u0000"+ + "\u0000\u113e\u0346\u0001\u0000\u0000\u0000\u113f\u1140\u0007\u0010\u0000"+ + "\u0000\u1140\u1141\u0007\u0011\u0000\u0000\u1141\u1142\u0007\u000f\u0000"+ + "\u0000\u1142\u1143\u0007\n\u0000\u0000\u1143\u0348\u0001\u0000\u0000\u0000"+ + "\u1144\u1145\u0007\u0010\u0000\u0000\u1145\u1146\u0007\u0011\u0000\u0000"+ + "\u1146\u1147\u0007\u000f\u0000\u0000\u1147\u1148\u0007\n\u0000\u0000\u1148"+ + "\u1149\u0007\t\u0000\u0000\u1149\u114a\u0007\u0010\u0000\u0000\u114a\u114b"+ + "\u0007\u0005\u0000\u0000\u114b\u114c\u0007\u000f\u0000\u0000\u114c\u114d"+ + "\u0007\u0018\u0000\u0000\u114d\u034a\u0001\u0000\u0000\u0000\u114e\u114f"+ + "\u0007\u0010\u0000\u0000\u114f\u1150\u0007\r\u0000\u0000\u1150\u1151\u0007"+ + "\n\u0000\u0000\u1151\u1152\u0007\u0005\u0000\u0000\u1152\u1153\u0007\u0010"+ + "\u0000\u0000\u1153\u034c\u0001\u0000\u0000\u0000\u1154\u1155\u0007\u0010"+ + "\u0000\u0000\u1155\u1156\u0007\r\u0000\u0000\u1156\u1157\u0007\u0011\u0000"+ + "\u0000\u1157\u1158\u0007\u000f\u0000\u0000\u1158\u034e\u0001\u0000\u0000"+ + "\u0000\u1159\u115a\u0007\u001b\u0000\u0000\u115a\u115b\u0007\u0005\u0000"+ + "\u0000\u115b\u115c\u0007\u0006\u0000\u0000\u115c\u115d\u0007\u0016\u0000"+ + "\u0000\u115d\u115e\u0007\n\u0000\u0000\u115e\u115f\u0007\t\u0000\u0000"+ + "\u115f\u0350\u0001\u0000\u0000\u0000\u1160\u1161\u0007\u001b\u0000\u0000"+ + "\u1161\u1162\u0007\u0005\u0000\u0000\u1162\u1163\u0007\r\u0000\u0000\u1163"+ + "\u1164\u0007\u000e\u0000\u0000\u1164\u1165\u0007\u0014\u0000\u0000\u1165"+ + "\u1166\u0007\u0005\u0000\u0000\u1166\u1167\u0007\r\u0000\u0000\u1167\u0352"+ + "\u0001\u0000\u0000\u0000\u1168\u1169\u0007\u001a\u0000\u0000\u1169\u116a"+ + "\u0007\u000f\u0000\u0000\u116a\u116b\u0007\u0006\u0000\u0000\u116b\u116c"+ + "\u0007\u0005\u0000\u0000\u116c\u116d\u0007\u0010\u0000\u0000\u116d\u116e"+ + "\u0007\u0010\u0000\u0000\u116e\u116f\u0007\r\u0000\u0000\u116f\u1170\u0007"+ + "\u0011\u0000\u0000\u1170\u1171\u0007\u0012\u0000\u0000\u1171\u1172\u0007"+ + "\u0016\u0000\u0000\u1172\u1173\u0007\u0010\u0000\u0000\u1173\u1174\u0007"+ + "\n\u0000\u0000\u1174\u1175\u0007\t\u0000\u0000\u1175\u0354\u0001\u0000"+ + "\u0000\u0000\u1176\u1177\u0007\u001a\u0000\u0000\u1177\u1178\u0007\u000f"+ + "\u0000\u0000\u1178\u1179\u0007\u0006\u0000\u0000\u1179\u117a\u0007\u000e"+ + "\u0000\u0000\u117a\u117b\u0007\u0013\u0000\u0000\u117b\u117c\u0007\u000f"+ + "\u0000\u0000\u117c\u117d\u0007\u000f\u0000\u0000\u117d\u117e\u0007\n\u0000"+ + "\u0000\u117e\u117f\u0007\u0007\u0000\u0000\u117f\u1180\u0007\u0010\u0000"+ + "\u0000\u1180\u0356\u0001\u0000\u0000\u0000\u1181\u1182\u0007\u001a\u0000"+ + "\u0000\u1182\u1183\u0007\u000f\u0000\u0000\u1183\u1184\u0007\u0006\u0000"+ + "\u0000\u1184\u1185\u0007\u0005\u0000\u0000\u1185\u1186\u0007\u0017\u0000"+ + "\u0000\u1186\u1187\u0007\u0017\u0000\u0000\u1187\u0358\u0001\u0000\u0000"+ + "\u0000\u1188\u1189\u0007\u001a\u0000\u0000\u1189\u118a\u0007\u000f\u0000"+ + "\u0000\u118a\u118b\u0007\u0006\u0000\u0000\u118b\u118c\u0005_\u0000\u0000"+ + "\u118c\u118d\u0007\u0011\u0000\u0000\u118d\u118e\u0007\t\u0000\u0000\u118e"+ + "\u118f\u0005_\u0000\u0000\u118f\u1190\u0007\u001d\u0000\u0000\u1190\u1191"+ + "\u0007\n\u0000\u0000\u1191\u1192\u0007\u0006\u0000\u0000\u1192\u1193\u0007"+ + "\u0006\u0000\u0000\u1193\u1194\u0005_\u0000\u0000\u1194\u1195\u0007\u0019"+ + "\u0000\u0000\u1195\u1196\u0007\u0013\u0000\u0000\u1196\u1197\u0007\r\u0000"+ + "\u0000\u1197\u1198\u0007\u000f\u0000\u0000\u1198\u1199\u0007\n\u0000\u0000"+ + "\u1199\u119a\u0007\f\u0000\u0000\u119a\u035a\u0001\u0000\u0000\u0000\u119b"+ + "\u119c\u0007\u001a\u0000\u0000\u119c\u119d\u0007\u000f\u0000\u0000\u119d"+ + "\u119e\u0007\u0006\u0000\u0000\u119e\u119f\u0005_\u0000\u0000\u119f\u11a0"+ + "\u0007\u0011\u0000\u0000\u11a0\u11a1\u0007\t\u0000\u0000\u11a1\u11a2\u0005"+ + "_\u0000\u0000\u11a2\u11a3\u0007\u001d\u0000\u0000\u11a3\u11a4\u0007\n"+ + "\u0000\u0000\u11a4\u11a5\u0007\u0006\u0000\u0000\u11a5\u11a6\u0007\u0006"+ + "\u0000\u0000\u11a6\u11a7\u0005_\u0000\u0000\u11a7\u11a8\u0007\u0019\u0000"+ + "\u0000\u11a8\u11a9\u0007\u0013\u0000\u0000\u11a9\u11aa\u0007\r\u0000\u0000"+ + "\u11aa\u11ab\u0007\u000f\u0000\u0000\u11ab\u11ac\u0007\n\u0000\u0000\u11ac"+ + "\u11ad\u0007\f\u0000\u0000\u11ad\u11ae\u0005_\u0000\u0000\u11ae\u11af"+ + "\u0007\f\u0000\u0000\u11af\u11b0\u0007\u0013\u0000\u0000\u11b0\u11b1\u0007"+ + "\u000e\u0000\u0000\u11b1\u11b2\u0007\u0016\u0000\u0000\u11b2\u11b3\u0007"+ + "\u000f\u0000\u0000\u11b3\u11b4\u0007\n\u0000\u0000\u11b4\u11b5\u0007\u0007"+ + "\u0000\u0000\u11b5\u11b6\u0007\u0010\u0000\u0000\u11b6\u035c\u0001\u0000"+ + "\u0000\u0000\u11b7\u11b8\u0007\u001a\u0000\u0000\u11b8\u11b9\u0007\u000f"+ + "\u0000\u0000\u11b9\u11ba\u0007\u0006\u0000\u0000\u11ba\u11bb\u0005_\u0000"+ + "\u0000\u11bb\u11bc\u0007\u0011\u0000\u0000\u11bc\u11bd\u0007\t\u0000\u0000"+ + "\u11bd\u11be\u0005_\u0000\u0000\u11be\u11bf\u0007\u001d\u0000\u0000\u11bf"+ + "\u11c0\u0007\n\u0000\u0000\u11c0\u11c1\u0007\u0006\u0000\u0000\u11c1\u11c2"+ + "\u0007\u0006\u0000\u0000\u11c2\u11c3\u0005_\u0000\u0000\u11c3\u11c4\u0007"+ + "\u0019\u0000\u0000\u11c4\u11c5\u0007\u0013\u0000\u0000\u11c5\u11c6\u0007"+ + "\r\u0000\u0000\u11c6\u11c7\u0007\u000f\u0000\u0000\u11c7\u11c8\u0007\n"+ + "\u0000\u0000\u11c8\u11c9\u0007\f\u0000\u0000\u11c9\u11ca\u0005_\u0000"+ + "\u0000\u11ca\u11cb\u0007\u000e\u0000\u0000\u11cb\u11cc\u0007\u0013\u0000"+ + "\u0000\u11cc\u11cd\u0007\u0007\u0000\u0000\u11cd\u11ce\u0007\u0010\u0000"+ + "\u0000\u11ce\u11cf\u0007\n\u0000\u0000\u11cf\u11d0\u0007\u0007\u0000\u0000"+ + "\u11d0\u11d1\u0007\u0010\u0000\u0000\u11d1\u035e\u0001\u0000\u0000\u0000"+ + "\u11d2\u11d3\u0007\u001a\u0000\u0000\u11d3\u11d4\u0007\u0018\u0000\u0000"+ + "\u11d4\u11d5\u0007\u0005\u0000\u0000\u11d5\u11d6\u0007\u0010\u0000\u0000"+ + "\u11d6\u11d7\u0007\u0014\u0000\u0000\u11d7\u0360\u0001\u0000\u0000\u0000"+ + "\u11d8\u11d9\u0007\u001a\u0000\u0000\u11d9\u11da\u0007\u0018\u0000\u0000"+ + "\u11da\u11db\u0007\u0005\u0000\u0000\u11db\u11dc\u0007\u0010\u0000\u0000"+ + "\u11dc\u11dd\u0007\u0014\u0000\u0000\u11dd\u11de\u0005_\u0000\u0000\u11de"+ + "\u11df\u0007\n\u0000\u0000\u11df\u11e0\u0007\u001a\u0000\u0000\u11e0\u11e1"+ + "\u0007\u0011\u0000\u0000\u11e1\u11e2\u0007\t\u0000\u0000\u11e2\u11e3\u0007"+ + "\u0010\u0000\u0000\u11e3\u11e4\u0007\t\u0000\u0000\u11e4\u0362\u0001\u0000"+ + "\u0000\u0000\u11e5\u11e6\u0007\u001a\u0000\u0000\u11e6\u11e7\u0007\u000f"+ + "\u0000\u0000\u11e7\u11e8\u0007\u0006\u0000\u0000\u11e8\u11e9\u0007\u000e"+ + "\u0000\u0000\u11e9\u11ea\u0007\u0013\u0000\u0000\u11ea\u11eb\u0007\u0007"+ + "\u0000\u0000\u11eb\u11ec\u0007\u000e\u0000\u0000\u11ec\u11ed\u0007\u0005"+ + "\u0000\u0000\u11ed\u11ee\u0007\u0010\u0000\u0000\u11ee\u0364\u0001\u0000"+ + "\u0000\u0000\u11ef\u11f0\u0007\u001a\u0000\u0000\u11f0\u11f1\u0007\u000f"+ + "\u0000\u0000\u11f1\u11f2\u0007\u0006\u0000\u0000\u11f2\u11f3\u0007\n\u0000"+ + "\u0000\u11f3\u11f4\u0007\u0006\u0000\u0000\u11f4\u11f5\u0007\n\u0000\u0000"+ + "\u11f5\u11f6\u0007\u000f\u0000\u0000\u11f6\u11f7\u0007\n\u0000\u0000\u11f7"+ + "\u11f8\u0007\u0007\u0000\u0000\u11f8\u11f9\u0007\u0010\u0000\u0000\u11f9"+ + "\u0366\u0001\u0000\u0000\u0000\u11fa\u11fb\u0007\u001a\u0000\u0000\u11fb"+ + "\u11fc\u0007\u000f\u0000\u0000\u11fc\u11fd\u0007\u0006\u0000\u0000\u11fd"+ + "\u11fe\u0007\n\u0000\u0000\u11fe\u11ff\u0007\u001a\u0000\u0000\u11ff\u1200"+ + "\u0007\u0011\u0000\u0000\u1200\u1201\u0007\t\u0000\u0000\u1201\u1202\u0007"+ + "\u0010\u0000\u0000\u1202\u1203\u0007\t\u0000\u0000\u1203\u0368\u0001\u0000"+ + "\u0000\u0000\u1204\u1205\u0007\u001a\u0000\u0000\u1205\u1206\u0007\u000f"+ + "\u0000\u0000\u1206\u1207\u0007\u0006\u0000\u0000\u1207\u1208\u0007\u0019"+ + "\u0000\u0000\u1208\u1209\u0007\u0013\u0000\u0000\u1209\u120a\u0007\r\u0000"+ + "\u0000\u120a\u120b\u0007\n\u0000\u0000\u120b\u120c\u0007\t\u0000\u0000"+ + "\u120c\u120d\u0007\u0010\u0000\u0000\u120d\u036a\u0001\u0000\u0000\u0000"+ + "\u120e\u120f\u0007\u001a\u0000\u0000\u120f\u1210\u0007\u000f\u0000\u0000"+ + "\u1210\u1211\u0007\u0006\u0000\u0000\u1211\u1212\u0007\u0018\u0000\u0000"+ + "\u1212\u1213\u0007\u0005\u0000\u0000\u1213\u1214\u0007\r\u0000\u0000\u1214"+ + "\u1215\u0007\t\u0000\u0000\u1215\u1216\u0007\n\u0000\u0000\u1216\u036c"+ + "\u0001\u0000\u0000\u0000\u1217\u1218\u0007\u001a\u0000\u0000\u1218\u1219"+ + "\u0007\u000f\u0000\u0000\u1219\u121a\u0007\u0006\u0000\u0000\u121a\u121b"+ + "\u0007\u0018\u0000\u0000\u121b\u121c\u0007\u0011\u0000\u0000\u121c\u036e"+ + "\u0001\u0000\u0000\u0000\u121d\u121e\u0007\u001a\u0000\u0000\u121e\u121f"+ + "\u0007\u000f\u0000\u0000\u121f\u1220\u0007\u0006\u0000\u0000\u1220\u1221"+ + "\u0007\r\u0000\u0000\u1221\u1222\u0007\u0013\u0000\u0000\u1222\u1223\u0007"+ + "\u0013\u0000\u0000\u1223\u1224\u0007\u0010\u0000\u0000\u1224\u0370\u0001"+ + "\u0000\u0000\u0000\u1225\u1226\u0007\u001a\u0000\u0000\u1226\u1227\u0007"+ + "\u000f\u0000\u0000\u1227\u1228\u0007\u0006\u0000\u0000\u1228\u1229\u0007"+ + "\t\u0000\u0000\u1229\u122a\u0007\n\u0000\u0000\u122a\u122b\u0007\r\u0000"+ + "\u0000\u122b\u122c\u0007\u0011\u0000\u0000\u122c\u122d\u0007\u0005\u0000"+ + "\u0000\u122d\u122e\u0007\u0006\u0000\u0000\u122e\u122f\u0007\u0011\u0000"+ + "\u0000\u122f\u1230\u0007\u000b\u0000\u0000\u1230\u1231\u0007\n\u0000\u0000"+ + "\u1231\u0372\u0001\u0000\u0000\u0000\u1232\u1233\u0007\u000e\u0000\u0000"+ + "\u1233\u1234\u0007\u0005\u0000\u0000\u1234\u1235\u0007\u0006\u0000\u0000"+ + "\u1235\u1236\u0007\u0006\u0000\u0000\u1236\u0374\u0001\u0000\u0000\u0000"+ + "\u1237\u1238\u0007\u000e\u0000\u0000\u1238\u1239\u0007\u0016\u0000\u0000"+ + "\u1239\u123a\u0007\r\u0000\u0000\u123a\u123b\u0007\r\u0000\u0000\u123b"+ + "\u123c\u0007\n\u0000\u0000\u123c\u123d\u0007\u0007\u0000\u0000\u123d\u123e"+ + "\u0007\u0010\u0000\u0000\u123e\u0376\u0001\u0000\u0000\u0000\u123f\u1240"+ + "\u0007\u0005\u0000\u0000\u1240\u1241\u0007\u0010\u0000\u0000\u1241\u1242"+ + "\u0007\u0010\u0000\u0000\u1242\u1243\u0007\u0005\u0000\u0000\u1243\u1244"+ + "\u0007\u000e\u0000\u0000\u1244\u1245\u0007\u0014\u0000\u0000\u1245\u0378"+ + "\u0001\u0000\u0000\u0000\u1246\u1247\u0007\f\u0000\u0000\u1247\u1248\u0007"+ + "\n\u0000\u0000\u1248\u1249\u0007\u0010\u0000\u0000\u1249\u124a\u0007\u0005"+ + "\u0000\u0000\u124a\u124b\u0007\u000e\u0000\u0000\u124b\u124c\u0007\u0014"+ + "\u0000\u0000\u124c\u037a\u0001\u0000\u0000\u0000\u124d\u124e\u0007\n\u0000"+ + "\u0000\u124e\u124f\u0007\u001a\u0000\u0000\u124f\u1250\u0007\u0018\u0000"+ + "\u0000\u1250\u1251\u0007\r\u0000\u0000\u1251\u1252\u0007\n\u0000\u0000"+ + "\u1252\u1253\u0007\t\u0000\u0000\u1253\u1254\u0007\t\u0000\u0000\u1254"+ + "\u1255\u0007\u0011\u0000\u0000\u1255\u1256\u0007\u0013\u0000\u0000\u1256"+ + "\u1257\u0007\u0007\u0000\u0000\u1257\u037c\u0001\u0000\u0000"; private static final String _serializedATNSegment2 = - "\u0fde\u0003\u0013\t\u0000\u0fde\u0fdf\u0003)\u0014\u0000\u0fdf\u0fe0"+ - "\u0003#\u0011\u0000\u0fe0\u0fe1\u0003/\u0017\u0000\u0fe1\u0fe2\u0003%"+ - "\u0012\u0000\u0fe2\u0232\u0001\u0000\u0000\u0000\u0fe3\u0fe4\u0003\u0013"+ - "\t\u0000\u0fe4\u0fe5\u0003)\u0014\u0000\u0fe5\u0fe6\u0003#\u0011\u0000"+ - "\u0fe6\u0fe7\u0003/\u0017\u0000\u0fe7\u0fe8\u0003%\u0012\u0000\u0fe8\u0fe9"+ - "\u0003\u0017\u000b\u0000\u0fe9\u0fea\u0003!\u0010\u0000\u0fea\u0feb\u0003"+ - "\u0013\t\u0000\u0feb\u0234\u0001\u0000\u0000\u0000\u0fec\u0fed\u0003\u0015"+ - "\n\u0000\u0fed\u0fee\u0003\u0007\u0003\u0000\u0fee\u0fef\u0003!\u0010"+ - "\u0000\u0fef\u0ff0\u0003\r\u0006\u0000\u0ff0\u0ff1\u0003\u001d\u000e\u0000"+ - "\u0ff1\u0ff2\u0003\u000f\u0007\u0000\u0ff2\u0ff3\u0003)\u0014\u0000\u0ff3"+ - "\u0236\u0001\u0000\u0000\u0000\u0ff4\u0ff5\u0003\u0015\n\u0000\u0ff5\u0ff6"+ - "\u0003\u0007\u0003\u0000\u0ff6\u0ff7\u00031\u0018\u0000\u0ff7\u0ff8\u0003"+ - "\u0017\u000b\u0000\u0ff8\u0ff9\u0003!\u0010\u0000\u0ff9\u0ffa\u0003\u0013"+ - "\t\u0000\u0ffa\u0238\u0001\u0000\u0000\u0000\u0ffb\u0ffc\u0003\u0015\n"+ - "\u0000\u0ffc\u0ffd\u0003\u0017\u000b\u0000\u0ffd\u0ffe\u0003\u000f\u0007"+ - "\u0000\u0ffe\u0fff\u0003)\u0014\u0000\u0fff\u1000\u0003\u0007\u0003\u0000"+ - "\u1000\u1001\u0003)\u0014\u0000\u1001\u1002\u0003\u000b\u0005\u0000\u1002"+ - "\u1003\u0003\u0015\n\u0000\u1003\u1004\u00037\u001b\u0000\u1004\u023a"+ - "\u0001\u0000\u0000\u0000\u1005\u1006\u0003\u0015\n\u0000\u1006\u1007\u0003"+ - "#\u0011\u0000\u1007\u1008\u0003\u001d\u000e\u0000\u1008\u1009\u0003\r"+ - "\u0006\u0000\u1009\u023c\u0001\u0000\u0000\u0000\u100a\u100b\u0003\u0015"+ - "\n\u0000\u100b\u100c\u0003#\u0011\u0000\u100c\u100d\u0003+\u0015\u0000"+ - "\u100d\u100e\u0003-\u0016\u0000\u100e\u023e\u0001\u0000\u0000\u0000\u100f"+ - "\u1010\u0003\u0015\n\u0000\u1010\u1011\u0003#\u0011\u0000\u1011\u1012"+ - "\u0003/\u0017\u0000\u1012\u1013\u0003)\u0014\u0000\u1013\u0240\u0001\u0000"+ - "\u0000\u0000\u1014\u1015\u0003\u0017\u000b\u0000\u1015\u1016\u0003\r\u0006"+ - "\u0000\u1016\u1017\u0003\u000f\u0007\u0000\u1017\u1018\u0003!\u0010\u0000"+ - "\u1018\u1019\u0003-\u0016\u0000\u1019\u101a\u0003\u0017\u000b\u0000\u101a"+ - "\u101b\u0003-\u0016\u0000\u101b\u101c\u00037\u001b\u0000\u101c\u0242\u0001"+ - "\u0000\u0000\u0000\u101d\u101e\u0003\u0017\u000b\u0000\u101e\u101f\u0003"+ - "\u0013\t\u0000\u101f\u1020\u0003!\u0010\u0000\u1020\u1021\u0003#\u0011"+ - "\u0000\u1021\u1022\u0003)\u0014\u0000\u1022\u1023\u0003\u000f\u0007\u0000"+ - "\u1023\u0244\u0001\u0000\u0000\u0000\u1024\u1025\u0003\u0017\u000b\u0000"+ - "\u1025\u1026\u0003\u001d\u000e\u0000\u1026\u1027\u0003\u0017\u000b\u0000"+ - "\u1027\u1028\u0003\u001b\r\u0000\u1028\u1029\u0003\u000f\u0007\u0000\u1029"+ - "\u0246\u0001\u0000\u0000\u0000\u102a\u102b\u0003\u0017\u000b\u0000\u102b"+ - "\u102c\u0003\u001f\u000f\u0000\u102c\u102d\u0003\u001f\u000f\u0000\u102d"+ - "\u102e\u0003\u000f\u0007\u0000\u102e\u102f\u0003\r\u0006\u0000\u102f\u1030"+ - "\u0003\u0017\u000b\u0000\u1030\u1031\u0003\u0007\u0003\u0000\u1031\u1032"+ - "\u0003-\u0016\u0000\u1032\u1033\u0003\u000f\u0007\u0000\u1033\u0248\u0001"+ - "\u0000\u0000\u0000\u1034\u1035\u0003\u0017\u000b\u0000\u1035\u1036\u0003"+ - "\u001f\u000f\u0000\u1036\u1037\u0003\u001f\u000f\u0000\u1037\u1038\u0003"+ - "/\u0017\u0000\u1038\u1039\u0003-\u0016\u0000\u1039\u103a\u0003\u0007\u0003"+ - "\u0000\u103a\u103b\u0003\t\u0004\u0000\u103b\u103c\u0003\u001d\u000e\u0000"+ - "\u103c\u103d\u0003\u000f\u0007\u0000\u103d\u024a\u0001\u0000\u0000\u0000"+ - "\u103e\u103f\u0003\u0017\u000b\u0000\u103f\u1040\u0003\u001f\u000f\u0000"+ - "\u1040\u1041\u0003%\u0012\u0000\u1041\u1042\u0003\u001d\u000e\u0000\u1042"+ - "\u1043\u0003\u000f\u0007\u0000\u1043\u1044\u0003\u001f\u000f\u0000\u1044"+ - "\u1045\u0003\u000f\u0007\u0000\u1045\u1046\u0003!\u0010\u0000\u1046\u1047"+ - "\u0003-\u0016\u0000\u1047\u1048\u0003\u0007\u0003\u0000\u1048\u1049\u0003"+ - "-\u0016\u0000\u1049\u104a\u0003\u0017\u000b\u0000\u104a\u104b\u0003#\u0011"+ - "\u0000\u104b\u104c\u0003!\u0010\u0000\u104c\u024c\u0001\u0000\u0000\u0000"+ - "\u104d\u104e\u0003\u0017\u000b\u0000\u104e\u104f\u0003\u001f\u000f\u0000"+ - "\u104f\u1050\u0003%\u0012\u0000\u1050\u1051\u0003\u001d\u000e\u0000\u1051"+ - "\u1052\u0003\u0017\u000b\u0000\u1052\u1053\u0003\u000b\u0005\u0000\u1053"+ - "\u1054\u0003\u0017\u000b\u0000\u1054\u1055\u0003-\u0016\u0000\u1055\u024e"+ - "\u0001\u0000\u0000\u0000\u1056\u1057\u0003\u0017\u000b\u0000\u1057\u1058"+ - "\u0003!\u0010\u0000\u1058\u0250\u0001\u0000\u0000\u0000\u1059\u105a\u0003"+ - "\u0017\u000b\u0000\u105a\u105b\u0003!\u0010\u0000\u105b\u105c\u0003\u000b"+ - "\u0005\u0000\u105c\u105d\u0003\u001d\u000e\u0000\u105d\u105e\u0003/\u0017"+ - "\u0000\u105e\u105f\u0003\r\u0006\u0000\u105f\u1060\u0003\u0017\u000b\u0000"+ - "\u1060\u1061\u0003!\u0010\u0000\u1061\u1062\u0003\u0013\t\u0000\u1062"+ - "\u0252\u0001\u0000\u0000\u0000\u1063\u1064\u0003\u0017\u000b\u0000\u1064"+ - "\u1065\u0003!\u0010\u0000\u1065\u1066\u0003\u000b\u0005\u0000\u1066\u1067"+ - "\u0003)\u0014\u0000\u1067\u1068\u0003\u000f\u0007\u0000\u1068\u1069\u0003"+ - "\u001f\u000f\u0000\u1069\u106a\u0003\u000f\u0007\u0000\u106a\u106b\u0003"+ - "!\u0010\u0000\u106b\u106c\u0003-\u0016\u0000\u106c\u0254\u0001\u0000\u0000"+ - "\u0000\u106d\u106e\u0003\u0017\u000b\u0000\u106e\u106f\u0003!\u0010\u0000"+ - "\u106f\u1070\u0003\r\u0006\u0000\u1070\u1071\u0003\u000f\u0007\u0000\u1071"+ - "\u1072\u00035\u001a\u0000\u1072\u0256\u0001\u0000\u0000\u0000\u1073\u1074"+ - "\u0003\u0017\u000b\u0000\u1074\u1075\u0003!\u0010\u0000\u1075\u1076\u0003"+ - "\r\u0006\u0000\u1076\u1077\u0003\u0017\u000b\u0000\u1077\u1078\u0003\u000b"+ - "\u0005\u0000\u1078\u1079\u0003\u0007\u0003\u0000\u1079\u107a\u0003-\u0016"+ - "\u0000\u107a\u107b\u0003#\u0011\u0000\u107b\u107c\u0003)\u0014\u0000\u107c"+ - "\u0258\u0001\u0000\u0000\u0000\u107d\u107e\u0003\u0017\u000b\u0000\u107e"+ - "\u107f\u0003!\u0010\u0000\u107f\u1080\u0003\u0011\b\u0000\u1080\u1081"+ - "\u0003\u0017\u000b\u0000\u1081\u1082\u00035\u001a\u0000\u1082\u025a\u0001"+ - "\u0000\u0000\u0000\u1083\u1084\u0003\u0017\u000b\u0000\u1084\u1085\u0003"+ - "!\u0010\u0000\u1085\u1086\u0003\u0015\n\u0000\u1086\u1087\u0003\u000f"+ - "\u0007\u0000\u1087\u1088\u0003)\u0014\u0000\u1088\u1089\u0003\u0017\u000b"+ - "\u0000\u1089\u108a\u0003-\u0016\u0000\u108a\u108b\u0003+\u0015\u0000\u108b"+ - "\u025c\u0001\u0000\u0000\u0000\u108c\u108d\u0003\u0017\u000b\u0000\u108d"+ - "\u108e\u0003!\u0010\u0000\u108e\u108f\u0003\u0017\u000b\u0000\u108f\u1090"+ - "\u0003-\u0016\u0000\u1090\u1091\u0003\u0017\u000b\u0000\u1091\u1092\u0003"+ - "\u0007\u0003\u0000\u1092\u1093\u0003\u001d\u000e\u0000\u1093\u1094\u0003"+ - "\u0017\u000b\u0000\u1094\u1095\u00039\u001c\u0000\u1095\u1096\u0003\u000f"+ - "\u0007\u0000\u1096\u025e\u0001\u0000\u0000\u0000\u1097\u1098\u0003\u0017"+ - "\u000b\u0000\u1098\u1099\u0003!\u0010\u0000\u1099\u109a\u0003\u0017\u000b"+ - "\u0000\u109a\u109b\u0003-\u0016\u0000\u109b\u109c\u0003\u0017\u000b\u0000"+ - "\u109c\u109d\u0003\u0007\u0003\u0000\u109d\u109e\u0003\u001d\u000e\u0000"+ - "\u109e\u109f\u0003\u001d\u000e\u0000\u109f\u10a0\u00037\u001b\u0000\u10a0"+ - "\u0260\u0001\u0000\u0000\u0000\u10a1\u10a2\u0003\u0017\u000b\u0000\u10a2"+ - "\u10a3\u0003!\u0010\u0000\u10a3\u10a4\u0003!\u0010\u0000\u10a4\u10a5\u0003"+ - "\u000f\u0007\u0000\u10a5\u10a6\u0003)\u0014\u0000\u10a6\u0262\u0001\u0000"+ - "\u0000\u0000\u10a7\u10a8\u0003\u0017\u000b\u0000\u10a8\u10a9\u0003!\u0010"+ - "\u0000\u10a9\u10aa\u0003#\u0011\u0000\u10aa\u10ab\u0003/\u0017\u0000\u10ab"+ - "\u10ac\u0003-\u0016\u0000\u10ac\u0264\u0001\u0000\u0000\u0000\u10ad\u10ae"+ - "\u0003\u0017\u000b\u0000\u10ae\u10af\u0003!\u0010\u0000\u10af\u10b0\u0003"+ - "%\u0012\u0000\u10b0\u10b1\u0003/\u0017\u0000\u10b1\u10b2\u0003-\u0016"+ - "\u0000\u10b2\u0266\u0001\u0000\u0000\u0000\u10b3\u10b4\u0003\u0017\u000b"+ - "\u0000\u10b4\u10b5\u0003!\u0010\u0000\u10b5\u10b6\u0003+\u0015\u0000\u10b6"+ - "\u10b7\u0003\u000f\u0007\u0000\u10b7\u10b8\u0003!\u0010\u0000\u10b8\u10b9"+ - "\u0003+\u0015\u0000\u10b9\u10ba\u0003\u0017\u000b\u0000\u10ba\u10bb\u0003"+ - "-\u0016\u0000\u10bb\u10bc\u0003\u0017\u000b\u0000\u10bc\u10bd\u00031\u0018"+ - "\u0000\u10bd\u10be\u0003\u000f\u0007\u0000\u10be\u0268\u0001\u0000\u0000"+ - "\u0000\u10bf\u10c0\u0003\u0017\u000b\u0000\u10c0\u10c1\u0003!\u0010\u0000"+ - "\u10c1\u10c2\u0003+\u0015\u0000\u10c2\u10c3\u0003\u000f\u0007\u0000\u10c3"+ - "\u10c4\u0003)\u0014\u0000\u10c4\u10c5\u0003-\u0016\u0000\u10c5\u026a\u0001"+ - "\u0000\u0000\u0000\u10c6\u10c7\u0003\u0017\u000b\u0000\u10c7\u10c8\u0003"+ - "!\u0010\u0000\u10c8\u10c9\u0003+\u0015\u0000\u10c9\u10ca\u0003-\u0016"+ - "\u0000\u10ca\u10cb\u0003\u0007\u0003\u0000\u10cb\u10cc\u0003!\u0010\u0000"+ - "\u10cc\u10cd\u0003\u000b\u0005\u0000\u10cd\u10ce\u0003\u000f\u0007\u0000"+ - "\u10ce\u026c\u0001\u0000\u0000\u0000\u10cf\u10d0\u0003\u0017\u000b\u0000"+ - "\u10d0\u10d1\u0003!\u0010\u0000\u10d1\u10d2\u0003+\u0015\u0000\u10d2\u10d3"+ - "\u0003-\u0016\u0000\u10d3\u10d4\u0003\u0007\u0003\u0000\u10d4\u10d5\u0003"+ - "!\u0010\u0000\u10d5\u10d6\u0003-\u0016\u0000\u10d6\u10d7\u0003\u0017\u000b"+ - "\u0000\u10d7\u10d8\u0003\u0007\u0003\u0000\u10d8\u10d9\u0003\t\u0004\u0000"+ - "\u10d9\u10da\u0003\u001d\u000e\u0000\u10da\u10db\u0003\u000f\u0007\u0000"+ - "\u10db\u026e\u0001\u0000\u0000\u0000\u10dc\u10dd\u0003\u0017\u000b\u0000"+ - "\u10dd\u10de\u0003!\u0010\u0000\u10de\u10df\u0003+\u0015\u0000\u10df\u10e0"+ - "\u0003-\u0016\u0000\u10e0\u10e1\u0003\u000f\u0007\u0000\u10e1\u10e2\u0003"+ - "\u0007\u0003\u0000\u10e2\u10e3\u0003\r\u0006\u0000\u10e3\u0270\u0001\u0000"+ - "\u0000\u0000\u10e4\u10e5\u0003\u0017\u000b\u0000\u10e5\u10e6\u0003!\u0010"+ - "\u0000\u10e6\u10e7\u0003-\u0016\u0000\u10e7\u0272\u0001\u0000\u0000\u0000"+ - "\u10e8\u10e9\u0003\u0017\u000b\u0000\u10e9\u10ea\u0003!\u0010\u0000\u10ea"+ - "\u10eb\u0003-\u0016\u0000\u10eb\u10ec\u0003\u000f\u0007\u0000\u10ec\u10ed"+ - "\u0003\u0013\t\u0000\u10ed\u10ee\u0003\u000f\u0007\u0000\u10ee\u10ef\u0003"+ - ")\u0014\u0000\u10ef\u0274\u0001\u0000\u0000\u0000\u10f0\u10f1\u0003\u0017"+ - "\u000b\u0000\u10f1\u10f2\u0003!\u0010\u0000\u10f2\u10f3\u0003-\u0016\u0000"+ - "\u10f3\u10f4\u0003\u000f\u0007\u0000\u10f4\u10f5\u0003)\u0014\u0000\u10f5"+ - "\u10f6\u0003+\u0015\u0000\u10f6\u10f7\u0003\u000f\u0007\u0000\u10f7\u10f8"+ - "\u0003\u000b\u0005\u0000\u10f8\u10f9\u0003-\u0016\u0000\u10f9\u0276\u0001"+ - "\u0000\u0000\u0000\u10fa\u10fb\u0003\u0017\u000b\u0000\u10fb\u10fc\u0003"+ - "!\u0010\u0000\u10fc\u10fd\u0003-\u0016\u0000\u10fd\u10fe\u0003\u000f\u0007"+ - "\u0000\u10fe\u10ff\u0003)\u0014\u0000\u10ff\u1100\u0003+\u0015\u0000\u1100"+ - "\u1101\u0003\u000f\u0007\u0000\u1101\u1102\u0003\u000b\u0005\u0000\u1102"+ - "\u1103\u0003-\u0016\u0000\u1103\u1104\u0003\u0017\u000b\u0000\u1104\u1105"+ - "\u0003#\u0011\u0000\u1105\u1106\u0003!\u0010\u0000\u1106\u0278\u0001\u0000"+ - "\u0000\u0000\u1107\u1108\u0003\u0017\u000b\u0000\u1108\u1109\u0003!\u0010"+ - "\u0000\u1109\u110a\u0003-\u0016\u0000\u110a\u110b\u0003\u000f\u0007\u0000"+ - "\u110b\u110c\u0003)\u0014\u0000\u110c\u110d\u00031\u0018\u0000\u110d\u110e"+ - "\u0003\u0007\u0003\u0000\u110e\u110f\u0003\u001d\u000e\u0000\u110f\u027a"+ - "\u0001\u0000\u0000\u0000\u1110\u1111\u0003\u0017\u000b\u0000\u1111\u1112"+ - "\u0003!\u0010\u0000\u1112\u1113\u0003-\u0016\u0000\u1113\u1114\u0003#"+ - "\u0011\u0000\u1114\u027c\u0001\u0000\u0000\u0000\u1115\u1116\u0003\u0017"+ - "\u000b\u0000\u1116\u1117\u0003!\u0010\u0000\u1117\u1118\u00031\u0018\u0000"+ - "\u1118\u1119\u0003#\u0011\u0000\u1119\u111a\u0003\u001b\r\u0000\u111a"+ - "\u111b\u0003\u000f\u0007\u0000\u111b\u111c\u0003)\u0014\u0000\u111c\u027e"+ - "\u0001\u0000\u0000\u0000\u111d\u111e\u0003\u0017\u000b\u0000\u111e\u111f"+ - "\u0003+\u0015\u0000\u111f\u0280\u0001\u0000\u0000\u0000\u1120\u1121\u0003"+ - "\u0017\u000b\u0000\u1121\u1122\u0003+\u0015\u0000\u1122\u1123\u0003#\u0011"+ - "\u0000\u1123\u1124\u0003\u001d\u000e\u0000\u1124\u1125\u0003\u0007\u0003"+ - "\u0000\u1125\u1126\u0003-\u0016\u0000\u1126\u1127\u0003\u0017\u000b\u0000"+ - "\u1127\u1128\u0003#\u0011\u0000\u1128\u1129\u0003!\u0010\u0000\u1129\u0282"+ - "\u0001\u0000\u0000\u0000\u112a\u112b\u0003\u0017\u000b\u0000\u112b\u112c"+ - "\u0003-\u0016\u0000\u112c\u112d\u0003\u000f\u0007\u0000\u112d\u112e\u0003"+ - ")\u0014\u0000\u112e\u112f\u0003\u0007\u0003\u0000\u112f\u1130\u0003-\u0016"+ - "\u0000\u1130\u1131\u0003\u000f\u0007\u0000\u1131\u0284\u0001\u0000\u0000"+ - "\u0000\u1132\u1133\u0003\u0019\f\u0000\u1133\u1134\u0003#\u0011\u0000"+ - "\u1134\u1135\u0003\u0017\u000b\u0000\u1135\u1136\u0003!\u0010\u0000\u1136"+ - "\u0286\u0001\u0000\u0000\u0000\u1137\u1138\u0003\u001b\r\u0000\u1138\u0288"+ - "\u0001\u0000\u0000\u0000\u1139\u113a\u0003\u001b\r\u0000\u113a\u113b\u0003"+ - "\u000f\u0007\u0000\u113b\u113c\u00037\u001b\u0000\u113c\u028a\u0001\u0000"+ - "\u0000\u0000\u113d\u113e\u0003\u001b\r\u0000\u113e\u113f\u0003\u000f\u0007"+ - "\u0000\u113f\u1140\u00037\u001b\u0000\u1140\u1141\u0005_\u0000\u0000\u1141"+ - "\u1142\u0003\u001f\u000f\u0000\u1142\u1143\u0003\u000f\u0007\u0000\u1143"+ - "\u1144\u0003\u001f\u000f\u0000\u1144\u1145\u0003\t\u0004\u0000\u1145\u1146"+ - "\u0003\u000f\u0007\u0000\u1146\u1147\u0003)\u0014\u0000\u1147\u028c\u0001"+ - "\u0000\u0000\u0000\u1148\u1149\u0003\u001b\r\u0000\u1149\u114a\u0003\u000f"+ - "\u0007\u0000\u114a\u114b\u00037\u001b\u0000\u114b\u114c\u0005_\u0000\u0000"+ - "\u114c\u114d\u0003-\u0016\u0000\u114d\u114e\u00037\u001b\u0000\u114e\u114f"+ - "\u0003%\u0012\u0000\u114f\u1150\u0003\u000f\u0007\u0000\u1150\u028e\u0001"+ - "\u0000\u0000\u0000\u1151\u1152\u0003\u001d\u000e\u0000\u1152\u1153\u0003"+ - "\u0007\u0003\u0000\u1153\u1154\u0003\t\u0004\u0000\u1154\u1155\u0003\u000f"+ - "\u0007\u0000\u1155\u1156\u0003\u001d\u000e\u0000\u1156\u0290\u0001\u0000"+ - "\u0000\u0000\u1157\u1158\u0003\u001d\u000e\u0000\u1158\u1159\u0003\u0007"+ - "\u0003\u0000\u1159\u115a\u0003!\u0010\u0000\u115a\u115b\u0003\u000b\u0005"+ - "\u0000\u115b\u115c\u0003#\u0011\u0000\u115c\u115d\u0003\u001f\u000f\u0000"+ - "\u115d\u115e\u0003%\u0012\u0000\u115e\u115f\u0003\u0017\u000b\u0000\u115f"+ - "\u1160\u0003\u001d\u000e\u0000\u1160\u1161\u0003\u000f\u0007\u0000\u1161"+ - "\u1162\u0003)\u0014\u0000\u1162\u0292\u0001\u0000\u0000\u0000\u1163\u1164"+ - "\u0003\u001d\u000e\u0000\u1164\u1165\u0003\u0007\u0003\u0000\u1165\u1166"+ - "\u0003!\u0010\u0000\u1166\u1167\u0003\u0013\t\u0000\u1167\u1168\u0003"+ - "/\u0017\u0000\u1168\u1169\u0003\u0007\u0003\u0000\u1169\u116a\u0003\u0013"+ - "\t\u0000\u116a\u116b\u0003\u000f\u0007\u0000\u116b\u0294\u0001\u0000\u0000"+ - "\u0000\u116c\u116d\u0003\u001d\u000e\u0000\u116d\u116e\u0003\u0007\u0003"+ - "\u0000\u116e\u116f\u0003)\u0014\u0000\u116f\u1170\u0003\u0013\t\u0000"+ - "\u1170\u1171\u0003\u000f\u0007\u0000\u1171\u0296\u0001\u0000\u0000\u0000"+ - "\u1172\u1173\u0003\u001d\u000e\u0000\u1173\u1174\u0003\u0007\u0003\u0000"+ - "\u1174\u1175\u0003+\u0015\u0000\u1175\u1176\u0003-\u0016\u0000\u1176\u0298"+ - "\u0001\u0000\u0000\u0000\u1177\u1178\u0003\u001d\u000e\u0000\u1178\u1179"+ - "\u0003\u0007\u0003\u0000\u1179\u117a\u0003-\u0016\u0000\u117a\u117b\u0003"+ - "\u000f\u0007\u0000\u117b\u117c\u0003)\u0014\u0000\u117c\u117d\u0003\u0007"+ - "\u0003\u0000\u117d\u117e\u0003\u001d\u000e\u0000\u117e\u029a\u0001\u0000"+ - "\u0000\u0000\u117f\u1180\u0003\u001d\u000e\u0000\u1180\u1181\u0003\u000f"+ - "\u0007\u0000\u1181\u1182\u0003\u0007\u0003\u0000\u1182\u1183\u0003\r\u0006"+ - "\u0000\u1183\u1184\u0003\u0017\u000b\u0000\u1184\u1185\u0003!\u0010\u0000"+ - "\u1185\u1186\u0003\u0013\t\u0000\u1186\u029c\u0001\u0000\u0000\u0000\u1187"+ - "\u1188\u0003\u001d\u000e\u0000\u1188\u1189\u0003\u000f\u0007\u0000\u1189"+ - "\u118a\u0003\u0007\u0003\u0000\u118a\u118b\u0003+\u0015\u0000\u118b\u118c"+ - "\u0003-\u0016\u0000\u118c\u029e\u0001\u0000\u0000\u0000\u118d\u118e\u0003"+ - "\u001d\u000e\u0000\u118e\u118f\u0003\u000f\u0007\u0000\u118f\u1190\u0003"+ - "\u0011\b\u0000\u1190\u1191\u0003-\u0016\u0000\u1191\u02a0\u0001\u0000"+ - "\u0000\u0000\u1192\u1193\u0003\u001d\u000e\u0000\u1193\u1194\u0003\u000f"+ - "\u0007\u0000\u1194\u1195\u0003!\u0010\u0000\u1195\u1196\u0003\u0013\t"+ - "\u0000\u1196\u1197\u0003-\u0016\u0000\u1197\u1198\u0003\u0015\n\u0000"+ - "\u1198\u02a2\u0001\u0000\u0000\u0000\u1199\u119a\u0003\u001d\u000e\u0000"+ - "\u119a\u119b\u0003\u000f\u0007\u0000\u119b\u119c\u0003+\u0015\u0000\u119c"+ - "\u119d\u0003+\u0015\u0000\u119d\u02a4\u0001\u0000\u0000\u0000\u119e\u119f"+ - "\u0003\u001d\u000e\u0000\u119f\u11a0\u0003\u000f\u0007\u0000\u11a0\u11a1"+ - "\u00031\u0018\u0000\u11a1\u11a2\u0003\u000f\u0007\u0000\u11a2\u11a3\u0003"+ - "\u001d\u000e\u0000\u11a3\u02a6\u0001\u0000\u0000\u0000\u11a4\u11a5\u0003"+ - "\u001d\u000e\u0000\u11a5\u11a6\u0003\u0017\u000b\u0000\u11a6\u11a7\u0003"+ - "\u001b\r\u0000\u11a7\u11a8\u0003\u000f\u0007\u0000\u11a8\u02a8\u0001\u0000"+ - "\u0000\u0000\u11a9\u11aa\u0003\u001d\u000e\u0000\u11aa\u11ab\u0003\u0017"+ - "\u000b\u0000\u11ab\u11ac\u0003\u001f\u000f\u0000\u11ac\u11ad\u0003\u0017"+ - "\u000b\u0000\u11ad\u11ae\u0003-\u0016\u0000\u11ae\u02aa\u0001\u0000\u0000"+ - "\u0000\u11af\u11b0\u0003\u001d\u000e\u0000\u11b0\u11b1\u0003\u0017\u000b"+ - "\u0000\u11b1\u11b2\u0003+\u0015\u0000\u11b2\u11b3\u0003-\u0016\u0000\u11b3"+ - "\u11b4\u0003\u000f\u0007\u0000\u11b4\u11b5\u0003!\u0010\u0000\u11b5\u02ac"+ - "\u0001\u0000\u0000\u0000\u11b6\u11b7\u0003\u001d\u000e\u0000\u11b7\u11b8"+ - "\u0003!\u0010\u0000\u11b8\u02ae\u0001\u0000\u0000\u0000\u11b9\u11ba\u0003"+ - "\u001d\u000e\u0000\u11ba\u11bb\u0003#\u0011\u0000\u11bb\u11bc\u0003\u0007"+ - "\u0003\u0000\u11bc\u11bd\u0003\r\u0006\u0000\u11bd\u02b0\u0001\u0000\u0000"+ - "\u0000\u11be\u11bf\u0003\u001d\u000e\u0000\u11bf\u11c0\u0003#\u0011\u0000"+ - "\u11c0\u11c1\u0003\u000b\u0005\u0000\u11c1\u11c2\u0003\u0007\u0003\u0000"+ - "\u11c2\u11c3\u0003\u001d\u000e\u0000\u11c3\u02b2\u0001\u0000\u0000\u0000"+ - "\u11c4\u11c5\u0003\u001d\u000e\u0000\u11c5\u11c6\u0003#\u0011\u0000\u11c6"+ - "\u11c7\u0003\u000b\u0005\u0000\u11c7\u11c8\u0003\u0007\u0003\u0000\u11c8"+ - "\u11c9\u0003\u001d\u000e\u0000\u11c9\u11ca\u0003-\u0016\u0000\u11ca\u11cb"+ - "\u0003\u0017\u000b\u0000\u11cb\u11cc\u0003\u001f\u000f\u0000\u11cc\u11cd"+ - "\u0003\u000f\u0007\u0000\u11cd\u02b4\u0001\u0000\u0000\u0000\u11ce\u11cf"+ - "\u0003\u001d\u000e\u0000\u11cf\u11d0\u0003#\u0011\u0000\u11d0\u11d1\u0003"+ - "\u000b\u0005\u0000\u11d1\u11d2\u0003\u0007\u0003\u0000\u11d2\u11d3\u0003"+ - "\u001d\u000e\u0000\u11d3\u11d4\u0003-\u0016\u0000\u11d4\u11d5\u0003\u0017"+ - "\u000b\u0000\u11d5\u11d6\u0003\u001f\u000f\u0000\u11d6\u11d7\u0003\u000f"+ - "\u0007\u0000\u11d7\u11d8\u0003+\u0015\u0000\u11d8\u11d9\u0003-\u0016\u0000"+ - "\u11d9\u11da\u0003\u0007\u0003\u0000\u11da\u11db\u0003\u001f\u000f\u0000"+ - "\u11db\u11dc\u0003%\u0012\u0000\u11dc\u02b6\u0001\u0000\u0000\u0000\u11dd"+ - "\u11de\u0003\u001d\u000e\u0000\u11de\u11df\u0003#\u0011\u0000\u11df\u11e0"+ - "\u0003\u000b\u0005\u0000\u11e0\u11e1\u0003\u0007\u0003\u0000\u11e1\u11e2"+ - "\u0003-\u0016\u0000\u11e2\u11e3\u0003\u0017\u000b\u0000\u11e3\u11e4\u0003"+ - "#\u0011\u0000\u11e4\u11e5\u0003!\u0010\u0000\u11e5\u02b8\u0001\u0000\u0000"+ - "\u0000\u11e6\u11e7\u0003\u001d\u000e\u0000\u11e7\u11e8\u0003#\u0011\u0000"+ - "\u11e8\u11e9\u0003\u000b\u0005\u0000\u11e9\u11ea\u0003\u0007\u0003\u0000"+ - "\u11ea\u11eb\u0003-\u0016\u0000\u11eb\u11ec\u0003#\u0011\u0000\u11ec\u11ed"+ - "\u0003)\u0014\u0000\u11ed\u02ba\u0001\u0000\u0000\u0000\u11ee\u11ef\u0003"+ - "\u001d\u000e\u0000\u11ef\u11f0\u0003#\u0011\u0000\u11f0\u11f1\u0003\u000b"+ - "\u0005\u0000\u11f1\u11f2\u0003\u001b\r\u0000\u11f2\u02bc\u0001\u0000\u0000"+ - "\u0000\u11f3\u11f4\u0003\u001d\u000e\u0000\u11f4\u11f5\u0003#\u0011\u0000"+ - "\u11f5\u11f6\u0003\u000b\u0005\u0000\u11f6\u11f7\u0003\u001b\r\u0000\u11f7"+ - "\u11f8\u0003\u000f\u0007\u0000\u11f8\u11f9\u0003\r\u0006\u0000\u11f9\u02be"+ - "\u0001\u0000\u0000\u0000\u11fa\u11fb\u0003\u001d\u000e\u0000\u11fb\u11fc"+ - "\u0003#\u0011\u0000\u11fc\u11fd\u00033\u0019\u0000\u11fd\u11fe\u0003\u000f"+ - "\u0007\u0000\u11fe\u11ff\u0003)\u0014\u0000\u11ff\u02c0\u0001\u0000\u0000"+ - "\u0000\u1200\u1201\u0003\u001f\u000f\u0000\u1201\u02c2\u0001\u0000\u0000"+ - "\u0000\u1202\u1203\u0003\u001f\u000f\u0000\u1203\u1204\u0003\u0007\u0003"+ - "\u0000\u1204\u1205\u0003\u0017\u000b\u0000\u1205\u1206\u0003!\u0010\u0000"+ - "\u1206\u02c4\u0001\u0000\u0000\u0000\u1207\u1208\u0003\u001f\u000f\u0000"+ - "\u1208\u1209\u0003\u0007\u0003\u0000\u1209\u120a\u0003%\u0012\u0000\u120a"+ - "\u02c6\u0001\u0000\u0000\u0000\u120b\u120c\u0003\u001f\u000f\u0000\u120c"+ - "\u120d\u0003\u0007\u0003\u0000\u120d\u120e\u0003%\u0012\u0000\u120e\u120f"+ - "\u0003%\u0012\u0000\u120f\u1210\u0003\u0017\u000b\u0000\u1210\u1211\u0003"+ - "!\u0010\u0000\u1211\u1212\u0003\u0013\t\u0000\u1212\u02c8\u0001\u0000"+ - "\u0000\u0000\u1213\u1214\u0003\u001f\u000f\u0000\u1214\u1215\u0003\u0007"+ - "\u0003\u0000\u1215\u1216\u0003-\u0016\u0000\u1216\u1217\u0003\u000b\u0005"+ - "\u0000\u1217\u1218\u0003\u0015\n\u0000\u1218\u02ca\u0001\u0000\u0000\u0000"+ - "\u1219\u121a\u0003\u001f\u000f\u0000\u121a\u121b\u0003\u0007\u0003\u0000"+ - "\u121b\u121c\u0003-\u0016\u0000\u121c\u121d\u0003\u000b\u0005\u0000\u121d"+ - "\u121e\u0003\u0015\n\u0000\u121e\u121f\u0005_\u0000\u0000\u121f\u1220"+ - "\u0003+\u0015\u0000\u1220\u1221\u0003\u0017\u000b\u0000\u1221\u1222\u0003"+ - "\u001f\u000f\u0000\u1222\u1223\u0003%\u0012\u0000\u1223\u1224\u0003\u001d"+ - "\u000e\u0000\u1224\u1225\u0003\u000f\u0007\u0000\u1225\u02cc\u0001\u0000"+ - "\u0000\u0000\u1226\u1227\u0003\u001f\u000f\u0000\u1227\u1228\u0003\u0007"+ - "\u0003\u0000\u1228\u1229\u0003-\u0016\u0000\u1229\u122a\u0003\u000b\u0005"+ - "\u0000\u122a\u122b\u0003\u0015\n\u0000\u122b\u122c\u0003\u000f\u0007\u0000"+ - "\u122c\u122d\u0003\r\u0006\u0000\u122d\u02ce\u0001\u0000\u0000\u0000\u122e"+ - "\u122f\u0003\u001f\u000f\u0000\u122f\u1230\u0003\u0007\u0003\u0000\u1230"+ - "\u1231\u00035\u001a\u0000\u1231\u02d0\u0001\u0000\u0000\u0000\u1232\u1233"+ - "\u0003\u001f\u000f\u0000\u1233\u1234\u0003\u0007\u0003\u0000\u1234\u1235"+ - "\u00035\u001a\u0000\u1235\u1236\u00031\u0018\u0000\u1236\u1237\u0003\u0007"+ - "\u0003\u0000\u1237\u1238\u0003\u001d\u000e\u0000\u1238\u1239\u0003/\u0017"+ - "\u0000\u1239\u123a\u0003\u000f\u0007\u0000\u123a\u02d2\u0001\u0000\u0000"+ - "\u0000\u123b\u123c\u0003\u001f\u000f\u0000\u123c\u123d\u0003\u000f\u0007"+ - "\u0000\u123d\u123e\u0003\u001f\u000f\u0000\u123e\u123f\u0003\t\u0004\u0000"+ - "\u123f\u1240\u0003\u000f\u0007\u0000\u1240\u1241\u0003)\u0014\u0000\u1241"+ - "\u02d4\u0001\u0000\u0000\u0000\u1242\u1243\u0003\u001f\u000f\u0000\u1243"+ - "\u1244\u0003\u000f\u0007\u0000\u1244\u1245\u0003)\u0014\u0000\u1245\u1246"+ - "\u0003\u0013\t\u0000\u1246\u1247\u0003\u000f\u0007\u0000\u1247\u02d6\u0001"+ - "\u0000\u0000\u0000\u1248\u1249\u0003\u001f\u000f\u0000\u1249\u124a\u0003"+ - "\u000f\u0007\u0000\u124a\u124b\u0003+\u0015\u0000\u124b\u124c\u0003+\u0015"+ - "\u0000\u124c\u124d\u0003\u0007\u0003\u0000\u124d\u124e\u0003\u0013\t\u0000"+ - "\u124e\u124f\u0003\u000f\u0007\u0000\u124f\u1250\u0005_\u0000\u0000\u1250"+ - "\u1251\u0003\u001d\u000e\u0000\u1251\u1252\u0003\u000f\u0007\u0000\u1252"+ - "\u1253\u0003!\u0010\u0000\u1253\u1254\u0003\u0013\t\u0000\u1254\u1255"+ - "\u0003-\u0016\u0000\u1255\u1256\u0003\u0015\n\u0000\u1256\u02d8\u0001"+ - "\u0000\u0000\u0000\u1257\u1258\u0003\u001f\u000f\u0000\u1258\u1259\u0003"+ - "\u000f\u0007\u0000\u1259\u125a\u0003+\u0015\u0000\u125a\u125b\u0003+\u0015"+ - "\u0000\u125b\u125c\u0003\u0007\u0003\u0000\u125c\u125d\u0003\u0013\t\u0000"+ - "\u125d\u125e\u0003\u000f\u0007\u0000\u125e\u125f\u0005_\u0000\u0000\u125f"+ - "\u1260\u0003#\u0011\u0000\u1260\u1261\u0003\u000b\u0005\u0000\u1261\u1262"+ - "\u0003-\u0016\u0000\u1262\u1263\u0003\u000f\u0007\u0000\u1263\u1264\u0003"+ - "-\u0016\u0000\u1264\u1265\u0005_\u0000\u0000\u1265\u1266\u0003\u001d\u000e"+ - "\u0000\u1266\u1267\u0003\u000f\u0007\u0000\u1267\u1268\u0003!\u0010\u0000"+ - "\u1268\u1269\u0003\u0013\t\u0000\u1269\u126a\u0003-\u0016\u0000\u126a"+ - "\u126b\u0003\u0015\n\u0000\u126b\u02da\u0001\u0000\u0000\u0000\u126c\u126d"+ - "\u0003\u001f\u000f\u0000\u126d\u126e\u0003\u000f\u0007\u0000\u126e\u126f"+ - "\u0003+\u0015\u0000\u126f\u1270\u0003+\u0015\u0000\u1270\u1271\u0003\u0007"+ - "\u0003\u0000\u1271\u1272\u0003\u0013\t\u0000\u1272\u1273\u0003\u000f\u0007"+ - "\u0000\u1273\u1274\u0005_\u0000\u0000\u1274\u1275\u0003-\u0016\u0000\u1275"+ - "\u1276\u0003\u000f\u0007\u0000\u1276\u1277\u00035\u001a\u0000\u1277\u1278"+ - "\u0003-\u0016\u0000\u1278\u02dc\u0001\u0000\u0000\u0000\u1279\u127a\u0003"+ - "\u001f\u000f\u0000\u127a\u127b\u0003\u000f\u0007\u0000\u127b\u127c\u0003"+ - "-\u0016\u0000\u127c\u127d\u0003\u0015\n\u0000\u127d\u127e\u0003#\u0011"+ - "\u0000\u127e\u127f\u0003\r\u0006\u0000\u127f\u02de\u0001\u0000\u0000\u0000"+ - "\u1280\u1281\u0003\u001f\u000f\u0000\u1281\u1282\u0003\u0017\u000b\u0000"+ - "\u1282\u1283\u0003!\u0010\u0000\u1283\u02e0\u0001\u0000\u0000\u0000\u1284"+ - "\u1285\u0003\u001f\u000f\u0000\u1285\u1286\u0003\u0017\u000b\u0000\u1286"+ - "\u1287\u0003!\u0010\u0000\u1287\u1288\u0003/\u0017\u0000\u1288\u1289\u0003"+ - "-\u0016\u0000\u1289\u128a\u0003\u000f\u0007\u0000\u128a\u02e2\u0001\u0000"+ - "\u0000\u0000\u128b\u128c\u0003\u001f\u000f\u0000\u128c\u128d\u0003\u0017"+ - "\u000b\u0000\u128d\u128e\u0003!\u0010\u0000\u128e\u128f\u00031\u0018\u0000"+ - "\u128f\u1290\u0003\u0007\u0003\u0000\u1290\u1291\u0003\u001d\u000e\u0000"+ - "\u1291\u1292\u0003/\u0017\u0000\u1292\u1293\u0003\u000f\u0007\u0000\u1293"+ - "\u02e4\u0001\u0000\u0000\u0000\u1294\u1295\u0003\u001f\u000f\u0000\u1295"+ - "\u1296\u0003#\u0011\u0000\u1296\u1297\u0003\r\u0006\u0000\u1297\u02e6"+ - "\u0001\u0000\u0000\u0000\u1298\u1299\u0003\u001f\u000f\u0000\u1299\u129a"+ - "\u0003#\u0011\u0000\u129a\u129b\u0003\r\u0006\u0000\u129b\u129c\u0003"+ - "\u000f\u0007\u0000\u129c\u02e8\u0001\u0000\u0000\u0000\u129d\u129e\u0003"+ - "\u001f\u000f\u0000\u129e\u129f\u0003#\u0011\u0000\u129f\u12a0\u0003\r"+ - "\u0006\u0000\u12a0\u12a1\u0003\u0017\u000b\u0000\u12a1\u12a2\u0003\u0011"+ - "\b\u0000\u12a2\u12a3\u0003\u0017\u000b\u0000\u12a3\u12a4\u0003\u000f\u0007"+ - "\u0000\u12a4\u12a5\u0003+\u0015\u0000\u12a5\u02ea\u0001\u0000\u0000\u0000"+ - "\u12a6\u12a7\u0003\u001f\u000f\u0000\u12a7\u12a8\u0003#\u0011\u0000\u12a8"+ - "\u12a9\u0003\r\u0006\u0000\u12a9\u12aa\u0003\u0017\u000b\u0000\u12aa\u12ab"+ - "\u0003\u0011\b\u0000\u12ab\u12ac\u00037\u001b\u0000\u12ac\u02ec\u0001"+ - "\u0000\u0000\u0000\u12ad\u12ae\u0003\u001f\u000f\u0000\u12ae\u12af\u0003"+ - "#\u0011\u0000\u12af\u12b0\u0003\r\u0006\u0000\u12b0\u12b1\u0003/\u0017"+ - "\u0000\u12b1\u12b2\u0003\u001d\u000e\u0000\u12b2\u12b3\u0003\u000f\u0007"+ - "\u0000\u12b3\u02ee\u0001\u0000\u0000\u0000\u12b4\u12b5\u0003\u001f\u000f"+ - "\u0000\u12b5\u12b6\u0003#\u0011\u0000\u12b6\u12b7\u0003!\u0010\u0000\u12b7"+ - "\u12b8\u0003-\u0016\u0000\u12b8\u12b9\u0003\u0015\n\u0000\u12b9\u02f0"+ - "\u0001\u0000\u0000\u0000\u12ba\u12bb\u0003\u001f\u000f\u0000\u12bb\u12bc"+ - "\u0003#\u0011\u0000\u12bc\u12bd\u0003)\u0014\u0000\u12bd\u12be\u0003\u000f"+ - "\u0007\u0000\u12be\u02f2\u0001\u0000\u0000\u0000\u12bf\u12c0\u0003\u001f"+ - "\u000f\u0000\u12c0\u12c1\u0003#\u0011\u0000\u12c1\u12c2\u00031\u0018\u0000"+ - "\u12c2\u12c3\u0003\u000f\u0007\u0000\u12c3\u02f4\u0001\u0000\u0000\u0000"+ - "\u12c4\u12c5\u0003\u001f\u000f\u0000\u12c5\u12c6\u0003/\u0017\u0000\u12c6"+ - "\u12c7\u0003\u001d\u000e\u0000\u12c7\u12c8\u0003-\u0016\u0000\u12c8\u12c9"+ - "\u0003\u0017\u000b\u0000\u12c9\u12ca\u0003+\u0015\u0000\u12ca\u12cb\u0003"+ - "\u000f\u0007\u0000\u12cb\u12cc\u0003-\u0016\u0000\u12cc\u02f6\u0001\u0000"+ - "\u0000\u0000\u12cd\u12ce\u0003\u001f\u000f\u0000\u12ce\u12cf\u0003/\u0017"+ - "\u0000\u12cf\u12d0\u0003\u001f\u000f\u0000\u12d0\u12d1\u0003%\u0012\u0000"+ - "\u12d1\u12d2\u0003+\u0015\u0000\u12d2\u02f8\u0001\u0000\u0000\u0000\u12d3"+ - "\u12d4\u0003!\u0010\u0000\u12d4\u12d5\u0003\u0007\u0003\u0000\u12d5\u12d6"+ - "\u0003\u001f\u000f\u0000\u12d6\u12d7\u0003\u000f\u0007\u0000\u12d7\u02fa"+ - "\u0001\u0000\u0000\u0000\u12d8\u12d9\u0003!\u0010\u0000\u12d9\u12da\u0003"+ - "\u0007\u0003\u0000\u12da\u12db\u0003\u001f\u000f\u0000\u12db\u12dc\u0003"+ - "\u000f\u0007\u0000\u12dc\u12dd\u0003+\u0015\u0000\u12dd\u02fc\u0001\u0000"+ - "\u0000\u0000\u12de\u12df\u0003!\u0010\u0000\u12df\u12e0\u0003\u0007\u0003"+ - "\u0000\u12e0\u12e1\u0003-\u0016\u0000\u12e1\u12e2\u0003\u0017\u000b\u0000"+ - "\u12e2\u12e3\u0003#\u0011\u0000\u12e3\u12e4\u0003!\u0010\u0000\u12e4\u12e5"+ - "\u0003\u0007\u0003\u0000\u12e5\u12e6\u0003\u001d\u000e\u0000\u12e6\u02fe"+ - "\u0001\u0000\u0000\u0000\u12e7\u12e8\u0003!\u0010\u0000\u12e8\u12e9\u0003"+ - "\u0007\u0003\u0000\u12e9\u12ea\u0003-\u0016\u0000\u12ea\u12eb\u0003/\u0017"+ - "\u0000\u12eb\u12ec\u0003)\u0014\u0000\u12ec\u12ed\u0003\u0007\u0003\u0000"+ - "\u12ed\u12ee\u0003\u001d\u000e\u0000\u12ee\u0300\u0001\u0000\u0000\u0000"+ - "\u12ef\u12f0\u0003!\u0010\u0000\u12f0\u12f1\u0003\u000b\u0005\u0000\u12f1"+ - "\u12f2\u0003\u0015\n\u0000\u12f2\u12f3\u0003\u0007\u0003\u0000\u12f3\u12f4"+ - "\u0003)\u0014\u0000\u12f4\u0302\u0001\u0000\u0000\u0000\u12f5\u12f6\u0003"+ - "!\u0010\u0000\u12f6\u12f7\u0003\u000b\u0005\u0000\u12f7\u12f8\u0003\u001d"+ - "\u000e\u0000\u12f8\u12f9\u0003#\u0011\u0000\u12f9\u12fa\u0003\t\u0004"+ - "\u0000\u12fa\u0304\u0001\u0000\u0000\u0000\u12fb\u12fc\u0003!\u0010\u0000"+ - "\u12fc\u12fd\u0003\u000f\u0007\u0000\u12fd\u12fe\u0003+\u0015\u0000\u12fe"+ - "\u12ff\u0003-\u0016\u0000\u12ff\u1300\u0003\u0017\u000b\u0000\u1300\u1301"+ - "\u0003!\u0010\u0000\u1301\u1302\u0003\u0013\t\u0000\u1302\u0306\u0001"+ - "\u0000\u0000\u0000\u1303\u1304\u0003!\u0010\u0000\u1304\u1305\u0003\u000f"+ - "\u0007\u0000\u1305\u1306\u00033\u0019\u0000\u1306\u0308\u0001\u0000\u0000"+ - "\u0000\u1307\u1308\u0003!\u0010\u0000\u1308\u1309\u0003\u000f\u0007\u0000"+ - "\u1309\u130a\u00035\u001a\u0000\u130a\u130b\u0003-\u0016\u0000\u130b\u030a"+ - "\u0001\u0000\u0000\u0000\u130c\u130d\u0003!\u0010\u0000\u130d\u130e\u0003"+ - "#\u0011\u0000\u130e\u030c\u0001\u0000\u0000\u0000\u130f\u1310\u0003!\u0010"+ - "\u0000\u1310\u1311\u0003#\u0011\u0000\u1311\u1312\u0003\u000b\u0005\u0000"+ - "\u1312\u1313\u0003)\u0014\u0000\u1313\u1314\u0003\u000f\u0007\u0000\u1314"+ - "\u1315\u0003\u0007\u0003\u0000\u1315\u1316\u0003-\u0016\u0000\u1316\u1317"+ - "\u0003\u000f\u0007\u0000\u1317\u1318\u0003\r\u0006\u0000\u1318\u1319\u0003"+ - "\t\u0004\u0000\u1319\u030e\u0001\u0000\u0000\u0000\u131a\u131b\u0003!"+ - "\u0010\u0000\u131b\u131c\u0003#\u0011\u0000\u131c\u131d\u0003\u000b\u0005"+ - "\u0000\u131d\u131e\u0003)\u0014\u0000\u131e\u131f\u0003\u000f\u0007\u0000"+ - "\u131f\u1320\u0003\u0007\u0003\u0000\u1320\u1321\u0003-\u0016\u0000\u1321"+ - "\u1322\u0003\u000f\u0007\u0000\u1322\u1323\u0003/\u0017\u0000\u1323\u1324"+ - "\u0003+\u0015\u0000\u1324\u1325\u0003\u000f\u0007\u0000\u1325\u1326\u0003"+ - ")\u0014\u0000\u1326\u0310\u0001\u0000\u0000\u0000\u1327\u1328\u0003!\u0010"+ - "\u0000\u1328\u1329\u0003#\u0011\u0000\u1329\u132a\u0003!\u0010\u0000\u132a"+ - "\u132b\u0003\u000f\u0007\u0000\u132b\u0312\u0001\u0000\u0000\u0000\u132c"+ - "\u132d\u0003!\u0010\u0000\u132d\u132e\u0003#\u0011\u0000\u132e\u132f\u0003"+ - ")\u0014\u0000\u132f\u1330\u0003\u001f\u000f\u0000\u1330\u1331\u0003\u0007"+ - "\u0003\u0000\u1331\u1332\u0003\u001d\u000e\u0000\u1332\u1333\u0003\u0017"+ - "\u000b\u0000\u1333\u1334\u00039\u001c\u0000\u1334\u1335\u0003\u000f\u0007"+ - "\u0000\u1335\u0314\u0001\u0000\u0000\u0000\u1336\u1337\u0003!\u0010\u0000"+ - "\u1337\u1338\u0003#\u0011\u0000\u1338\u1339\u0003)\u0014\u0000\u1339\u133a"+ - "\u0003\u001f\u000f\u0000\u133a\u133b\u0003\u0007\u0003\u0000\u133b\u133c"+ - "\u0003\u001d\u000e\u0000\u133c\u133d\u0003\u0017\u000b\u0000\u133d\u133e"+ - "\u00039\u001c\u0000\u133e\u133f\u0003\u000f\u0007\u0000\u133f\u1340\u0003"+ - "\r\u0006\u0000\u1340\u0316\u0001\u0000\u0000\u0000\u1341\u1342\u0003!"+ - "\u0010\u0000\u1342\u1343\u0003#\u0011\u0000\u1343\u1344\u0003-\u0016\u0000"+ - "\u1344\u0318\u0001\u0000\u0000\u0000\u1345\u1346\u0003!\u0010\u0000\u1346"+ - "\u1347\u0003#\u0011\u0000\u1347\u1348\u0003-\u0016\u0000\u1348\u1349\u0003"+ - "\u0015\n\u0000\u1349\u134a\u0003\u0017\u000b\u0000\u134a\u134b\u0003!"+ - "\u0010\u0000\u134b\u134c\u0003\u0013\t\u0000\u134c\u031a\u0001\u0000\u0000"+ - "\u0000\u134d\u134e\u0003!\u0010\u0000\u134e\u134f\u0003#\u0011\u0000\u134f"+ - "\u1350\u0003-\u0016\u0000\u1350\u1351\u0003\u0017\u000b\u0000\u1351\u1352"+ - "\u0003\u0011\b\u0000\u1352\u1353\u00037\u001b\u0000\u1353\u031c\u0001"+ - "\u0000\u0000\u0000\u1354\u1355\u0003!\u0010\u0000\u1355\u1356\u0003#\u0011"+ - "\u0000\u1356\u1357\u0003-\u0016\u0000\u1357\u1358\u0003!\u0010\u0000\u1358"+ - "\u1359\u0003/\u0017\u0000\u1359\u135a\u0003\u001d\u000e\u0000\u135a\u135b"+ - "\u0003\u001d\u000e\u0000\u135b\u031e\u0001\u0000\u0000\u0000\u135c\u135d"+ - "\u0003!\u0010\u0000\u135d\u135e\u0003#\u0011\u0000\u135e\u135f\u00033"+ - "\u0019\u0000\u135f\u1360\u0003\u0007\u0003\u0000\u1360\u1361\u0003\u0017"+ - "\u000b\u0000\u1361\u1362\u0003-\u0016\u0000\u1362\u0320\u0001\u0000\u0000"+ - "\u0000\u1363\u1364\u0003!\u0010\u0000\u1364\u1365\u0003/\u0017\u0000\u1365"+ - "\u1366\u0003\u001d\u000e\u0000\u1366\u1367\u0003\u001d\u000e\u0000\u1367"+ - "\u0322\u0001\u0000\u0000\u0000\u1368\u1369\u0003!\u0010\u0000\u1369\u136a"+ - "\u0003/\u0017\u0000\u136a\u136b\u0003\u001d\u000e\u0000\u136b\u136c\u0003"+ - "\u001d\u000e\u0000\u136c\u136d\u0003\u0007\u0003\u0000\u136d\u136e\u0003"+ - "\t\u0004\u0000\u136e\u136f\u0003\u001d\u000e\u0000\u136f\u1370\u0003\u000f"+ - "\u0007\u0000\u1370\u0324\u0001\u0000\u0000\u0000\u1371\u1372\u0003!\u0010"+ - "\u0000\u1372\u1373\u0003/\u0017\u0000\u1373\u1374\u0003\u001d\u000e\u0000"+ - "\u1374\u1375\u0003\u001d\u000e\u0000\u1375\u1376\u0003\u0017\u000b\u0000"+ - "\u1376\u1377\u0003\u0011\b\u0000\u1377\u0326\u0001\u0000\u0000\u0000\u1378"+ - "\u1379\u0003!\u0010\u0000\u1379\u137a\u0003/\u0017\u0000\u137a\u137b\u0003"+ - "\u001d\u000e\u0000\u137b\u137c\u0003\u001d\u000e\u0000\u137c\u137d\u0003"+ - "+\u0015\u0000\u137d\u0328\u0001\u0000\u0000\u0000\u137e\u137f\u0003!\u0010"+ - "\u0000\u137f\u1380\u0003/\u0017\u0000\u1380\u1381\u0003\u001f\u000f\u0000"+ - "\u1381\u1382\u0003\t\u0004\u0000\u1382\u1383\u0003\u000f\u0007\u0000\u1383"+ - "\u1384\u0003)\u0014\u0000\u1384\u032a\u0001\u0000\u0000\u0000\u1385\u1386"+ - "\u0003!\u0010\u0000\u1386\u1387\u0003/\u0017\u0000\u1387\u1388\u0003\u001f"+ - "\u000f\u0000\u1388\u1389\u0003\u000f\u0007\u0000\u1389\u138a\u0003)\u0014"+ - "\u0000\u138a\u138b\u0003\u0017\u000b\u0000\u138b\u138c\u0003\u000b\u0005"+ - "\u0000\u138c\u032c\u0001\u0000\u0000\u0000\u138d\u138e\u0003#\u0011\u0000"+ - "\u138e\u138f\u0003\t\u0004\u0000\u138f\u1390\u0003\u0019\f\u0000\u1390"+ - "\u1391\u0003\u000f\u0007\u0000\u1391\u1392\u0003\u000b\u0005\u0000\u1392"+ - "\u1393\u0003-\u0016\u0000\u1393\u032e\u0001\u0000\u0000\u0000\u1394\u1395"+ - "\u0003#\u0011\u0000\u1395\u1396\u0003\u000b\u0005\u0000\u1396\u1397\u0003"+ - "-\u0016\u0000\u1397\u1398\u0003\u000f\u0007\u0000\u1398\u1399\u0003-\u0016"+ - "\u0000\u1399\u139a\u0005_\u0000\u0000\u139a\u139b\u0003\u001d\u000e\u0000"+ - "\u139b\u139c\u0003\u000f\u0007\u0000\u139c\u139d\u0003!\u0010\u0000\u139d"+ - "\u139e\u0003\u0013\t\u0000\u139e\u139f\u0003-\u0016\u0000\u139f\u13a0"+ - "\u0003\u0015\n\u0000\u13a0\u0330\u0001\u0000\u0000\u0000\u13a1\u13a2\u0003"+ - "#\u0011\u0000\u13a2\u13a3\u0003\u000b\u0005\u0000\u13a3\u13a4\u0003-\u0016"+ - "\u0000\u13a4\u13a5\u0003\u000f\u0007\u0000\u13a5\u13a6\u0003-\u0016\u0000"+ - "\u13a6\u13a7\u0003+\u0015\u0000\u13a7\u0332\u0001\u0000\u0000\u0000\u13a8"+ - "\u13a9\u0003#\u0011\u0000\u13a9\u13aa\u0003\u0011\b\u0000\u13aa\u0334"+ - "\u0001\u0000\u0000\u0000\u13ab\u13ac\u0003#\u0011\u0000\u13ac\u13ad\u0003"+ - "\u0011\b\u0000\u13ad\u13ae\u0003\u0011\b\u0000\u13ae\u0336\u0001\u0000"+ - "\u0000\u0000\u13af\u13b0\u0003#\u0011\u0000\u13b0\u13b1\u0003\u0011\b"+ - "\u0000\u13b1\u13b2\u0003\u0011\b\u0000\u13b2\u13b3\u0003+\u0015\u0000"+ - "\u13b3\u13b4\u0003\u000f\u0007\u0000\u13b4\u13b5\u0003-\u0016\u0000\u13b5"+ - "\u0338\u0001\u0000\u0000\u0000\u13b6\u13b7\u0003#\u0011\u0000\u13b7\u13b8"+ - "\u0003\u0017\u000b\u0000\u13b8\u13b9\u0003\r\u0006\u0000\u13b9\u13ba\u0003"+ - "+\u0015\u0000\u13ba\u033a\u0001\u0000\u0000\u0000\u13bb\u13bc\u0003#\u0011"+ - "\u0000\u13bc\u13bd\u0003\u001d\u000e\u0000\u13bd\u13be\u0003\r\u0006\u0000"+ - "\u13be\u033c\u0001\u0000\u0000\u0000\u13bf\u13c0\u0003#\u0011\u0000\u13c0"+ - "\u13c1\u0003!\u0010\u0000\u13c1\u033e\u0001\u0000\u0000\u0000\u13c2\u13c3"+ - "\u0003#\u0011\u0000\u13c3\u13c4\u0003!\u0010\u0000\u13c4\u13c5\u0003\u001d"+ - "\u000e\u0000\u13c5\u13c6\u00037\u001b\u0000\u13c6\u0340\u0001\u0000\u0000"+ - "\u0000\u13c7\u13c8\u0003#\u0011\u0000\u13c8\u13c9\u0003%\u0012\u0000\u13c9"+ - "\u13ca\u0003\u000f\u0007\u0000\u13ca\u13cb\u0003!\u0010\u0000\u13cb\u0342"+ - "\u0001\u0000\u0000\u0000\u13cc\u13cd\u0003#\u0011\u0000\u13cd\u13ce\u0003"+ - "%\u0012\u0000\u13ce\u13cf\u0003\u000f\u0007\u0000\u13cf\u13d0\u0003)\u0014"+ - "\u0000\u13d0\u13d1\u0003\u0007\u0003\u0000\u13d1\u13d2\u0003-\u0016\u0000"+ - "\u13d2\u13d3\u0003\u0017\u000b\u0000\u13d3\u13d4\u0003#\u0011\u0000\u13d4"+ - "\u13d5\u0003!\u0010\u0000\u13d5\u0344\u0001\u0000\u0000\u0000\u13d6\u13d7"+ - "\u0003#\u0011\u0000\u13d7\u13d8\u0003%\u0012\u0000\u13d8\u13d9\u0003\u000f"+ - "\u0007\u0000\u13d9\u13da\u0003)\u0014\u0000\u13da\u13db\u0003\u0007\u0003"+ - "\u0000\u13db\u13dc\u0003-\u0016\u0000\u13dc\u13dd\u0003#\u0011\u0000\u13dd"+ - "\u13de\u0003)\u0014\u0000\u13de\u0346\u0001\u0000\u0000\u0000\u13df\u13e0"+ - "\u0003#\u0011\u0000\u13e0\u13e1\u0003%\u0012\u0000\u13e1\u13e2\u0003-"+ - "\u0016\u0000\u13e2\u13e3\u0003\u0017\u000b\u0000\u13e3\u13e4\u0003#\u0011"+ - "\u0000\u13e4\u13e5\u0003!\u0010\u0000\u13e5\u0348\u0001\u0000\u0000\u0000"+ - "\u13e6\u13e7\u0003#\u0011\u0000\u13e7\u13e8\u0003%\u0012\u0000\u13e8\u13e9"+ - "\u0003-\u0016\u0000\u13e9\u13ea\u0003\u0017\u000b\u0000\u13ea\u13eb\u0003"+ - "#\u0011\u0000\u13eb\u13ec\u0003!\u0010\u0000\u13ec\u13ed\u0003+\u0015"+ - "\u0000\u13ed\u034a\u0001\u0000\u0000\u0000\u13ee\u13ef\u0003#\u0011\u0000"+ - "\u13ef\u13f0\u0003)\u0014\u0000\u13f0\u034c\u0001\u0000\u0000\u0000\u13f1"+ - "\u13f2\u0003#\u0011\u0000\u13f2\u13f3\u0003)\u0014\u0000\u13f3\u13f4\u0003"+ - "\r\u0006\u0000\u13f4\u13f5\u0003\u000f\u0007\u0000\u13f5\u13f6\u0003)"+ - "\u0014\u0000\u13f6\u034e\u0001\u0000\u0000\u0000\u13f7\u13f8\u0003#\u0011"+ - "\u0000\u13f8\u13f9\u0003)\u0014\u0000\u13f9\u13fa\u0003\r\u0006\u0000"+ - "\u13fa\u13fb\u0003\u000f\u0007\u0000\u13fb\u13fc\u0003)\u0014\u0000\u13fc"+ - "\u13fd\u0003\u0017\u000b\u0000\u13fd\u13fe\u0003!\u0010\u0000\u13fe\u13ff"+ - "\u0003\u0013\t\u0000\u13ff\u0350\u0001\u0000\u0000\u0000\u1400\u1401\u0003"+ - "#\u0011\u0000\u1401\u1402\u0003)\u0014\u0000\u1402\u1403\u0003\r\u0006"+ - "\u0000\u1403\u1404\u0003\u0017\u000b\u0000\u1404\u1405\u0003!\u0010\u0000"+ - "\u1405\u1406\u0003\u0007\u0003\u0000\u1406\u1407\u0003\u001d\u000e\u0000"+ - "\u1407\u1408\u0003\u0017\u000b\u0000\u1408\u1409\u0003-\u0016\u0000\u1409"+ - "\u140a\u00037\u001b\u0000\u140a\u0352\u0001\u0000\u0000\u0000\u140b\u140c"+ - "\u0003#\u0011\u0000\u140c\u140d\u0003-\u0016\u0000\u140d\u140e\u0003\u0015"+ - "\n\u0000\u140e\u140f\u0003\u000f\u0007\u0000\u140f\u1410\u0003)\u0014"+ - "\u0000\u1410\u1411\u0003+\u0015\u0000\u1411\u0354\u0001\u0000\u0000\u0000"+ - "\u1412\u1413\u0003#\u0011\u0000\u1413\u1414\u0003/\u0017\u0000\u1414\u1415"+ - "\u0003-\u0016\u0000\u1415\u0356\u0001\u0000\u0000\u0000\u1416\u1417\u0003"+ - "#\u0011\u0000\u1417\u1418\u0003/\u0017\u0000\u1418\u1419\u0003-\u0016"+ - "\u0000\u1419\u141a\u0003\u000f\u0007\u0000\u141a\u141b\u0003)\u0014\u0000"+ - "\u141b\u0358\u0001\u0000\u0000\u0000\u141c\u141d\u0003#\u0011\u0000\u141d"+ - "\u141e\u0003/\u0017\u0000\u141e\u141f\u0003-\u0016\u0000\u141f\u1420\u0003"+ - "%\u0012\u0000\u1420\u1421\u0003/\u0017\u0000\u1421\u1422\u0003-\u0016"+ - "\u0000\u1422\u035a\u0001\u0000\u0000\u0000\u1423\u1424\u0003#\u0011\u0000"+ - "\u1424\u1425\u00031\u0018\u0000\u1425\u1426\u0003\u000f\u0007\u0000\u1426"+ - "\u1427\u0003)\u0014\u0000\u1427\u035c\u0001\u0000\u0000\u0000\u1428\u1429"+ - "\u0003#\u0011\u0000\u1429\u142a\u00031\u0018\u0000\u142a\u142b\u0003\u000f"+ - "\u0007\u0000\u142b\u142c\u0003)\u0014\u0000\u142c\u142d\u0003\u001d\u000e"+ - "\u0000\u142d\u142e\u0003\u0007\u0003\u0000\u142e\u142f\u0003%\u0012\u0000"+ - "\u142f\u1430\u0003+\u0015\u0000\u1430\u035e\u0001\u0000\u0000\u0000\u1431"+ - "\u1432\u0003#\u0011\u0000\u1432\u1433\u00031\u0018\u0000\u1433\u1434\u0003"+ - "\u000f\u0007\u0000\u1434\u1435\u0003)\u0014\u0000\u1435\u1436\u0003\u001d"+ - "\u000e\u0000\u1436\u1437\u0003\u0007\u0003\u0000\u1437\u1438\u00037\u001b"+ - "\u0000\u1438\u0360\u0001\u0000\u0000\u0000\u1439\u143a\u0003#\u0011\u0000"+ - "\u143a\u143b\u00031\u0018\u0000\u143b\u143c\u0003\u000f\u0007\u0000\u143c"+ - "\u143d\u0003)\u0014\u0000\u143d\u143e\u0003)\u0014\u0000\u143e\u143f\u0003"+ - "\u0017\u000b\u0000\u143f\u1440\u0003\r\u0006\u0000\u1440\u1441\u0003\u0017"+ - "\u000b\u0000\u1441\u1442\u0003!\u0010\u0000\u1442\u1443\u0003\u0013\t"+ - "\u0000\u1443\u0362\u0001\u0000\u0000\u0000\u1444\u1445\u0003#\u0011\u0000"+ - "\u1445\u1446\u00033\u0019\u0000\u1446\u1447\u0003!\u0010\u0000\u1447\u1448"+ - "\u0003\u000f\u0007\u0000\u1448\u1449\u0003)\u0014\u0000\u1449\u0364\u0001"+ - "\u0000\u0000\u0000\u144a\u144b\u0003%\u0012\u0000\u144b\u144c\u0003\u0007"+ - "\u0003\u0000\u144c\u144d\u0003\r\u0006\u0000\u144d\u0366\u0001\u0000\u0000"+ - "\u0000\u144e\u144f\u0003%\u0012\u0000\u144f\u1450\u0003\u0007\u0003\u0000"+ - "\u1450\u1451\u0003)\u0014\u0000\u1451\u1452\u0003\u0007\u0003\u0000\u1452"+ - "\u1453\u0003\u001f\u000f\u0000\u1453\u1454\u0003\u000f\u0007\u0000\u1454"+ - "\u1455\u0003-\u0016\u0000\u1455\u1456\u0003\u000f\u0007\u0000\u1456\u1457"+ - "\u0003)\u0014\u0000\u1457\u0368\u0001\u0000\u0000\u0000\u1458\u1459\u0003"+ - "%\u0012\u0000\u1459\u145a\u0003\u0007\u0003\u0000\u145a\u145b\u0003)\u0014"+ - "\u0000\u145b\u145c\u0003\u0007\u0003\u0000\u145c\u145d\u0003\u001f\u000f"+ - "\u0000\u145d\u145e\u0003\u000f\u0007\u0000\u145e\u145f\u0003-\u0016\u0000"+ - "\u145f\u1460\u0003\u000f\u0007\u0000\u1460\u1461\u0003)\u0014\u0000\u1461"+ - "\u1462\u0005_\u0000\u0000\u1462\u1463\u0003\u001f\u000f\u0000\u1463\u1464"+ - "\u0003#\u0011\u0000\u1464\u1465\u0003\r\u0006\u0000\u1465\u1466\u0003"+ - "\u000f\u0007\u0000\u1466\u036a\u0001\u0000\u0000\u0000\u1467\u1468\u0003"+ - "%\u0012\u0000\u1468\u1469\u0003\u0007\u0003\u0000\u1469\u146a\u0003)\u0014"+ - "\u0000\u146a\u146b\u0003\u0007\u0003\u0000\u146b\u146c\u0003\u001f\u000f"+ - "\u0000\u146c\u146d\u0003\u000f\u0007\u0000\u146d\u146e\u0003-\u0016\u0000"+ - "\u146e\u146f\u0003\u000f\u0007\u0000\u146f\u1470\u0003)\u0014\u0000\u1470"+ - "\u1471\u0005_\u0000\u0000\u1471\u1472\u0003!\u0010\u0000\u1472\u1473\u0003"+ - "\u0007\u0003\u0000\u1473\u1474\u0003\u001f\u000f\u0000\u1474\u1475\u0003"+ - "\u000f\u0007\u0000\u1475\u036c\u0001\u0000\u0000\u0000\u1476\u1477\u0003"+ - "%\u0012\u0000\u1477\u1478\u0003\u0007\u0003\u0000\u1478\u1479\u0003)\u0014"+ - "\u0000\u1479\u147a\u0003\u0007\u0003\u0000\u147a\u147b\u0003\u001f\u000f"+ - "\u0000\u147b\u147c\u0003\u000f\u0007\u0000\u147c\u147d\u0003-\u0016\u0000"+ - "\u147d\u147e\u0003\u000f\u0007\u0000\u147e\u147f\u0003)\u0014\u0000\u147f"+ - "\u1480\u0005_\u0000\u0000\u1480\u1481\u0003#\u0011\u0000\u1481\u1482\u0003"+ - ")\u0014\u0000\u1482\u1483\u0003\r\u0006\u0000\u1483\u1484\u0003\u0017"+ - "\u000b\u0000\u1484\u1485\u0003!\u0010\u0000\u1485\u1486\u0003\u0007\u0003"+ - "\u0000\u1486\u1487\u0003\u001d\u000e\u0000\u1487\u1488\u0005_\u0000\u0000"+ - "\u1488\u1489\u0003%\u0012\u0000\u1489\u148a\u0003#\u0011\u0000\u148a\u148b"+ - "\u0003+\u0015\u0000\u148b\u148c\u0003\u0017\u000b\u0000\u148c\u148d\u0003"+ - "-\u0016\u0000\u148d\u148e\u0003\u0017\u000b\u0000\u148e\u148f\u0003#\u0011"+ - "\u0000\u148f\u1490\u0003!\u0010\u0000\u1490\u036e\u0001\u0000\u0000\u0000"+ - "\u1491\u1492\u0003%\u0012\u0000\u1492\u1493\u0003\u0007\u0003\u0000\u1493"+ - "\u1494\u0003)\u0014\u0000\u1494\u1495\u0003\u0007\u0003\u0000\u1495\u1496"+ - "\u0003\u001f\u000f\u0000\u1496\u1497\u0003\u000f\u0007\u0000\u1497\u1498"+ - "\u0003-\u0016\u0000\u1498\u1499\u0003\u000f\u0007\u0000\u1499\u149a\u0003"+ - ")\u0014\u0000\u149a\u149b\u0005_\u0000\u0000\u149b\u149c\u0003+\u0015"+ - "\u0000\u149c\u149d\u0003%\u0012\u0000\u149d\u149e\u0003\u000f\u0007\u0000"+ - "\u149e\u149f\u0003\u000b\u0005\u0000\u149f\u14a0\u0003\u0017\u000b\u0000"+ - "\u14a0\u14a1\u0003\u0011\b\u0000\u14a1\u14a2\u0003\u0017\u000b\u0000\u14a2"+ - "\u14a3\u0003\u000b\u0005\u0000\u14a3\u14a4\u0005_\u0000\u0000\u14a4\u14a5"+ - "\u0003\u000b\u0005\u0000\u14a5\u14a6\u0003\u0007\u0003\u0000\u14a6\u14a7"+ - "\u0003-\u0016\u0000\u14a7\u14a8\u0003\u0007\u0003\u0000\u14a8\u14a9\u0003"+ - "\u001d\u000e\u0000\u14a9\u14aa\u0003#\u0011\u0000\u14aa\u14ab\u0003\u0013"+ - "\t\u0000\u14ab\u0370\u0001\u0000\u0000\u0000\u14ac\u14ad\u0003%\u0012"+ - "\u0000\u14ad\u14ae\u0003\u0007\u0003\u0000\u14ae\u14af\u0003)\u0014\u0000"+ - "\u14af\u14b0\u0003\u0007\u0003\u0000\u14b0\u14b1\u0003\u001f\u000f\u0000"+ - "\u14b1\u14b2\u0003\u000f\u0007\u0000\u14b2\u14b3\u0003-\u0016\u0000\u14b3"+ - "\u14b4\u0003\u000f\u0007\u0000\u14b4\u14b5\u0003)\u0014\u0000\u14b5\u14b6"+ - "\u0005_\u0000\u0000\u14b6\u14b7\u0003+\u0015\u0000\u14b7\u14b8\u0003%"+ - "\u0012\u0000\u14b8\u14b9\u0003\u000f\u0007\u0000\u14b9\u14ba\u0003\u000b"+ - "\u0005\u0000\u14ba\u14bb\u0003\u0017\u000b\u0000\u14bb\u14bc\u0003\u0011"+ - "\b\u0000\u14bc\u14bd\u0003\u0017\u000b\u0000\u14bd\u14be\u0003\u000b\u0005"+ - "\u0000\u14be\u14bf\u0005_\u0000\u0000\u14bf\u14c0\u0003!\u0010\u0000\u14c0"+ - "\u14c1\u0003\u0007\u0003\u0000\u14c1\u14c2\u0003\u001f\u000f\u0000\u14c2"+ - "\u14c3\u0003\u000f\u0007\u0000\u14c3\u0372\u0001\u0000\u0000\u0000\u14c4"+ - "\u14c5\u0003%\u0012\u0000\u14c5\u14c6\u0003\u0007\u0003\u0000\u14c6\u14c7"+ - "\u0003)\u0014\u0000\u14c7\u14c8\u0003\u0007\u0003\u0000\u14c8\u14c9\u0003"+ - "\u001f\u000f\u0000\u14c9\u14ca\u0003\u000f\u0007\u0000\u14ca\u14cb\u0003"+ - "-\u0016\u0000\u14cb\u14cc\u0003\u000f\u0007\u0000\u14cc\u14cd\u0003)\u0014"+ - "\u0000\u14cd\u14ce\u0005_\u0000\u0000\u14ce\u14cf\u0003+\u0015\u0000\u14cf"+ - "\u14d0\u0003%\u0012\u0000\u14d0\u14d1\u0003\u000f\u0007\u0000\u14d1\u14d2"+ - "\u0003\u000b\u0005\u0000\u14d2\u14d3\u0003\u0017\u000b\u0000\u14d3\u14d4"+ - "\u0003\u0011\b\u0000\u14d4\u14d5\u0003\u0017\u000b\u0000\u14d5\u14d6\u0003"+ - "\u000b\u0005\u0000\u14d6\u14d7\u0005_\u0000\u0000\u14d7\u14d8\u0003+\u0015"+ - "\u0000\u14d8\u14d9\u0003\u000b\u0005\u0000\u14d9\u14da\u0003\u0015\n\u0000"+ - "\u14da\u14db\u0003\u000f\u0007\u0000\u14db\u14dc\u0003\u001f\u000f\u0000"+ - "\u14dc\u14dd\u0003\u0007\u0003\u0000\u14dd\u0374\u0001\u0000\u0000\u0000"+ - "\u14de\u14df\u0003%\u0012\u0000\u14df\u14e0\u0003\u0007\u0003\u0000\u14e0"+ - "\u14e1\u0003)\u0014\u0000\u14e1\u14e2\u0003\u0007\u0003\u0000\u14e2\u14e3"+ - "\u0003\u001f\u000f\u0000\u14e3\u14e4\u0003\u000f\u0007\u0000\u14e4\u14e5"+ - "\u0003-\u0016\u0000\u14e5\u14e6\u0003\u000f\u0007\u0000\u14e6\u14e7\u0003"+ - ")\u0014\u0000\u14e7\u14e8\u0003+\u0015\u0000\u14e8\u0376\u0001\u0000\u0000"+ - "\u0000\u14e9\u14ea\u0003%\u0012\u0000\u14ea\u14eb\u0003\u0007\u0003\u0000"+ - "\u14eb\u14ec\u0003)\u0014\u0000\u14ec\u14ed\u0003+\u0015\u0000\u14ed\u14ee"+ - "\u0003\u000f\u0007\u0000\u14ee\u14ef\u0003)\u0014\u0000\u14ef\u0378\u0001"+ - "\u0000\u0000\u0000\u14f0\u14f1\u0003%\u0012\u0000\u14f1\u14f2\u0003\u0007"+ - "\u0003\u0000\u14f2\u14f3\u0003)\u0014\u0000\u14f3\u14f4\u0003-\u0016\u0000"+ - "\u14f4\u14f5\u0003\u0017\u000b\u0000\u14f5\u14f6\u0003\u0007\u0003\u0000"+ - "\u14f6\u14f7\u0003\u001d\u000e\u0000\u14f7\u037a\u0001\u0000\u0000\u0000"+ - "\u14f8\u14f9\u0003%\u0012\u0000\u14f9\u14fa\u0003\u0007\u0003\u0000\u14fa"+ - "\u14fb\u0003)\u0014\u0000\u14fb\u14fc\u0003-\u0016\u0000\u14fc\u14fd\u0003"+ - "\u0017\u000b\u0000\u14fd\u14fe\u0003-\u0016\u0000\u14fe\u14ff\u0003\u0017"+ - "\u000b\u0000\u14ff\u1500\u0003#\u0011\u0000\u1500\u1501\u0003!\u0010\u0000"+ - "\u1501\u037c\u0001\u0000\u0000\u0000\u1502\u1503\u0003%\u0012\u0000\u1503"+ - "\u1504\u0003\u0007\u0003\u0000\u1504\u1505\u0003+\u0015\u0000\u1505\u1506"+ - "\u0003\u000b\u0005\u0000\u1506\u1507\u0003\u0007\u0003\u0000\u1507\u1508"+ - "\u0003\u001d\u000e\u0000\u1508\u037e\u0001\u0000\u0000\u0000\u1509\u150a"+ - "\u0003%\u0012\u0000\u150a\u150b\u0003\u0007\u0003\u0000\u150b\u150c\u0003"+ - "+\u0015\u0000\u150c\u150d\u0003+\u0015\u0000\u150d\u150e\u00033\u0019"+ - "\u0000\u150e\u150f\u0003#\u0011\u0000\u150f\u1510\u0003)\u0014\u0000\u1510"+ - "\u1511\u0003\r\u0006\u0000\u1511\u0380\u0001\u0000\u0000\u0000\u1512\u1513"+ - "\u0003%\u0012\u0000\u1513\u1514\u0003\u0007\u0003\u0000\u1514\u1515\u0003"+ - "-\u0016\u0000\u1515\u1516\u0003\u0015\n\u0000\u1516\u0382\u0001\u0000"+ - "\u0000\u0000\u1517\u1518\u0003%\u0012\u0000\u1518\u1519\u0003\u000f\u0007"+ - "\u0000\u1519\u151a\u0003)\u0014\u0000\u151a\u151b\u0003\u000b\u0005\u0000"+ - "\u151b\u151c\u0003\u000f\u0007\u0000\u151c\u151d\u0003!\u0010\u0000\u151d"+ - "\u151e\u0003-\u0016\u0000\u151e\u151f\u0005_\u0000\u0000\u151f\u1520\u0003"+ - ")\u0014\u0000\u1520\u1521\u0003\u0007\u0003\u0000\u1521\u1522\u0003!\u0010"+ - "\u0000\u1522\u1523\u0003\u001b\r\u0000\u1523\u0384\u0001\u0000\u0000\u0000"+ - "\u1524\u1525\u0003%\u0012\u0000\u1525\u1526\u0003\u000f\u0007\u0000\u1526"+ - "\u1527\u0003)\u0014\u0000\u1527\u1528\u0003\u000b\u0005\u0000\u1528\u1529"+ - "\u0003\u000f\u0007\u0000\u1529\u152a\u0003!\u0010\u0000\u152a\u152b\u0003"+ - "-\u0016\u0000\u152b\u152c\u0003\u0017\u000b\u0000\u152c\u152d\u0003\u001d"+ - "\u000e\u0000\u152d\u152e\u0003\u000f\u0007\u0000\u152e\u152f\u0005_\u0000"+ - "\u0000\u152f\u1530\u0003\u000b\u0005\u0000\u1530\u1531\u0003#\u0011\u0000"+ - "\u1531\u1532\u0003!\u0010\u0000\u1532\u1533\u0003-\u0016\u0000\u1533\u0386"+ - "\u0001\u0000\u0000\u0000\u1534\u1535\u0003%\u0012\u0000\u1535\u1536\u0003"+ - "\u000f\u0007\u0000\u1536\u1537\u0003)\u0014\u0000\u1537\u1538\u0003\u000b"+ - "\u0005\u0000\u1538\u1539\u0003\u000f\u0007\u0000\u1539\u153a\u0003!\u0010"+ - "\u0000\u153a\u153b\u0003-\u0016\u0000\u153b\u153c\u0003\u0017\u000b\u0000"+ - "\u153c\u153d\u0003\u001d\u000e\u0000\u153d\u153e\u0003\u000f\u0007\u0000"+ - "\u153e\u153f\u0005_\u0000\u0000\u153f\u1540\u0003\r\u0006\u0000\u1540"+ - "\u1541\u0003\u0017\u000b\u0000\u1541\u1542\u0003+\u0015\u0000\u1542\u1543"+ - "\u0003\u000b\u0005\u0000\u1543\u0388\u0001\u0000\u0000\u0000\u1544\u1545"+ - "\u0003%\u0012\u0000\u1545\u1546\u0003\u001d\u000e\u0000\u1546\u1547\u0003"+ - "\u0007\u0003\u0000\u1547\u1548\u0003\u000b\u0005\u0000\u1548\u1549\u0003"+ - "\u0017\u000b\u0000\u1549\u154a\u0003!\u0010\u0000\u154a\u154b\u0003\u0013"+ - "\t\u0000\u154b\u038a\u0001\u0000\u0000\u0000\u154c\u154d\u0003%\u0012"+ - "\u0000\u154d\u154e\u0003\u001d\u000e\u0000\u154e\u154f\u0003\u0007\u0003"+ - "\u0000\u154f\u1550\u0003\u0017\u000b\u0000\u1550\u1551\u0003!\u0010\u0000"+ - "\u1551\u038c\u0001\u0000\u0000\u0000\u1552\u1553\u0003%\u0012\u0000\u1553"+ - "\u1554\u0003\u001d\u000e\u0000\u1554\u1555\u0003\u0007\u0003\u0000\u1555"+ - "\u1556\u0003!\u0010\u0000\u1556\u1557\u0003+\u0015\u0000\u1557\u038e\u0001"+ - "\u0000\u0000\u0000\u1558\u1559\u0003%\u0012\u0000\u1559\u155a\u0003\u001d"+ - "\u000e\u0000\u155a\u155b\u0003\u0017\u000b\u0000\u155b\u0390\u0001\u0000"+ - "\u0000\u0000\u155c\u155d\u0003%\u0012\u0000\u155d\u155e\u0003#\u0011\u0000"+ - "\u155e\u155f\u0003+\u0015\u0000\u155f\u1560\u0003\u0017\u000b\u0000\u1560"+ - "\u1561\u0003-\u0016\u0000\u1561\u1562\u0003\u0017\u000b\u0000\u1562\u1563"+ - "\u0003#\u0011\u0000\u1563\u1564\u0003!\u0010\u0000\u1564\u0392\u0001\u0000"+ - "\u0000\u0000\u1565\u1566\u0003%\u0012\u0000\u1566\u1567\u0003#\u0011\u0000"+ - "\u1567\u1568\u0003+\u0015\u0000\u1568\u1569\u0003-\u0016\u0000\u1569\u156a"+ - "\u0003\u0011\b\u0000\u156a\u156b\u0003\u0017\u000b\u0000\u156b\u156c\u0003"+ - "5\u001a\u0000\u156c\u0394\u0001\u0000\u0000\u0000\u156d\u156e\u0003%\u0012"+ - "\u0000\u156e\u156f\u0003#\u0011\u0000\u156f\u1570\u00033\u0019\u0000\u1570"+ - "\u1571\u0003\u000f\u0007\u0000\u1571\u1572\u0003)\u0014\u0000\u1572\u0396"+ - "\u0001\u0000\u0000\u0000\u1573\u1574\u0003%\u0012\u0000\u1574\u1575\u0003"+ - ")\u0014\u0000\u1575\u1576\u0003\u000f\u0007\u0000\u1576\u1577\u0003\u000b"+ - "\u0005\u0000\u1577\u1578\u0003\u000f\u0007\u0000\u1578\u1579\u0003\r\u0006"+ - "\u0000\u1579\u157a\u0003\u0017\u000b\u0000\u157a\u157b\u0003!\u0010\u0000"+ - "\u157b\u157c\u0003\u0013\t\u0000\u157c\u0398\u0001\u0000\u0000\u0000\u157d"+ - "\u157e\u0003%\u0012\u0000\u157e\u157f\u0003)\u0014\u0000\u157f\u1580\u0003"+ - "\u000f\u0007\u0000\u1580\u1581\u0003\u000b\u0005\u0000\u1581\u1582\u0003"+ - "\u0017\u000b\u0000\u1582\u1583\u0003+\u0015\u0000\u1583\u1584\u0003\u0017"+ - "\u000b\u0000\u1584\u1585\u0003#\u0011\u0000\u1585\u1586\u0003!\u0010\u0000"+ - "\u1586\u039a\u0001\u0000\u0000\u0000\u1587\u1588\u0003%\u0012\u0000\u1588"+ - "\u1589\u0003)\u0014\u0000\u1589\u158a\u0003\u000f\u0007\u0000\u158a\u158b"+ - "\u0003\u0011\b\u0000\u158b\u158c\u0003\u0017\u000b\u0000\u158c\u158d\u0003"+ - "5\u001a\u0000\u158d\u039c\u0001\u0000\u0000\u0000\u158e\u158f\u0003%\u0012"+ - "\u0000\u158f\u1590\u0003)\u0014\u0000\u1590\u1591\u0003\u000f\u0007\u0000"+ - "\u1591\u1592\u0003#\u0011\u0000\u1592\u1593\u0003)\u0014\u0000\u1593\u1594"+ - "\u0003\r\u0006\u0000\u1594\u1595\u0003\u000f\u0007\u0000\u1595\u1596\u0003"+ - ")\u0014\u0000\u1596\u039e\u0001\u0000\u0000\u0000\u1597\u1598\u0003%\u0012"+ - "\u0000\u1598\u1599\u0003)\u0014\u0000\u1599\u159a\u0003\u000f\u0007\u0000"+ - "\u159a\u159b\u0003%\u0012\u0000\u159b\u159c\u0003\u0007\u0003\u0000\u159c"+ - "\u159d\u0003)\u0014\u0000\u159d\u159e\u0003\u000f\u0007\u0000\u159e\u03a0"+ - "\u0001\u0000\u0000\u0000\u159f\u15a0\u0003%\u0012\u0000\u15a0\u15a1\u0003"+ - ")\u0014\u0000\u15a1\u15a2\u0003\u000f\u0007\u0000\u15a2\u15a3\u0003%\u0012"+ - "\u0000\u15a3\u15a4\u0003\u0007\u0003\u0000\u15a4\u15a5\u0003)\u0014\u0000"+ - "\u15a5\u15a6\u0003\u000f\u0007\u0000\u15a6\u15a7\u0003\r\u0006\u0000\u15a7"+ - "\u03a2\u0001\u0000\u0000\u0000\u15a8\u15a9\u0003%\u0012\u0000\u15a9\u15aa"+ - "\u0003)\u0014\u0000\u15aa\u15ab\u0003\u000f\u0007\u0000\u15ab\u15ac\u0003"+ - "+\u0015\u0000\u15ac\u15ad\u0003\u000f\u0007\u0000\u15ad\u15ae\u0003)\u0014"+ - "\u0000\u15ae\u15af\u00031\u0018\u0000\u15af\u15b0\u0003\u000f\u0007\u0000"+ - "\u15b0\u03a4\u0001\u0000\u0000\u0000\u15b1\u15b2\u0003%\u0012\u0000\u15b2"+ - "\u15b3\u0003)\u0014\u0000\u15b3\u15b4\u0003\u0017\u000b\u0000\u15b4\u15b5"+ - "\u0003\u001f\u000f\u0000\u15b5\u15b6\u0003\u0007\u0003\u0000\u15b6\u15b7"+ - "\u0003)\u0014\u0000\u15b7\u15b8\u00037\u001b\u0000\u15b8\u03a6\u0001\u0000"+ - "\u0000\u0000\u15b9\u15ba\u0003%\u0012\u0000\u15ba\u15bb\u0003)\u0014\u0000"+ - "\u15bb\u15bc\u0003\u0017\u000b\u0000\u15bc\u15bd\u0003#\u0011\u0000\u15bd"+ - "\u15be\u0003)\u0014\u0000\u15be\u03a8\u0001\u0000\u0000\u0000\u15bf\u15c0"+ - "\u0003%\u0012\u0000\u15c0\u15c1\u0003)\u0014\u0000\u15c1\u15c2\u0003\u0017"+ - "\u000b\u0000\u15c2\u15c3\u00031\u0018\u0000\u15c3\u15c4\u0003\u0017\u000b"+ - "\u0000\u15c4\u15c5\u0003\u001d\u000e\u0000\u15c5\u15c6\u0003\u000f\u0007"+ - "\u0000\u15c6\u15c7\u0003\u0013\t\u0000\u15c7\u15c8\u0003\u000f\u0007\u0000"+ - "\u15c8\u15c9\u0003+\u0015\u0000\u15c9\u03aa\u0001\u0000\u0000\u0000\u15ca"+ - "\u15cb\u0003%\u0012\u0000\u15cb\u15cc\u0003)\u0014\u0000\u15cc\u15cd\u0003"+ - "#\u0011\u0000\u15cd\u15ce\u0003\u000b\u0005\u0000\u15ce\u15cf\u0003\u000f"+ - "\u0007\u0000\u15cf\u15d0\u0003\r\u0006\u0000\u15d0\u15d1\u0003/\u0017"+ - "\u0000\u15d1\u15d2\u0003)\u0014\u0000\u15d2\u15d3\u0003\u0007\u0003\u0000"+ - "\u15d3\u15d4\u0003\u001d\u000e\u0000\u15d4\u03ac\u0001\u0000\u0000\u0000"+ - "\u15d5\u15d6\u0003%\u0012\u0000\u15d6\u15d7\u0003)\u0014\u0000\u15d7\u15d8"+ - "\u0003#\u0011\u0000\u15d8\u15d9\u0003\u000b\u0005\u0000\u15d9\u15da\u0003"+ - "\u000f\u0007\u0000\u15da\u15db\u0003\r\u0006\u0000\u15db\u15dc\u0003/"+ - "\u0017\u0000\u15dc\u15dd\u0003)\u0014\u0000\u15dd\u15de\u0003\u000f\u0007"+ - "\u0000\u15de\u03ae\u0001\u0000\u0000\u0000\u15df\u15e0\u0003%\u0012\u0000"+ - "\u15e0\u15e1\u0003/\u0017\u0000\u15e1\u15e2\u0003\t\u0004\u0000\u15e2"+ - "\u15e3\u0003\u001d\u000e\u0000\u15e3\u15e4\u0003\u0017\u000b\u0000\u15e4"+ - "\u15e5\u0003\u000b\u0005\u0000\u15e5\u03b0\u0001\u0000\u0000\u0000\u15e6"+ - "\u15e7\u0003%\u0012\u0000\u15e7\u15e8\u0003/\u0017\u0000\u15e8\u15e9\u0003"+ - "\t\u0004\u0000\u15e9\u15ea\u0003\u001d\u000e\u0000\u15ea\u15eb\u0003\u0017"+ - "\u000b\u0000\u15eb\u15ec\u0003\u000b\u0005\u0000\u15ec\u15ed\u0003\u0007"+ - "\u0003\u0000\u15ed\u15ee\u0003-\u0016\u0000\u15ee\u15ef\u0003\u0017\u000b"+ - "\u0000\u15ef\u15f0\u0003#\u0011\u0000\u15f0\u15f1\u0003!\u0010\u0000\u15f1"+ - "\u03b2\u0001\u0000\u0000\u0000\u15f2\u15f3\u0003\'\u0013\u0000\u15f3\u15f4"+ - "\u0003/\u0017\u0000\u15f4\u15f5\u0003#\u0011\u0000\u15f5\u15f6\u0003-"+ - "\u0016\u0000\u15f6\u15f7\u0003\u000f\u0007\u0000\u15f7\u03b4\u0001\u0000"+ - "\u0000\u0000\u15f8\u15f9\u0003)\u0014\u0000\u15f9\u15fa\u0003\u0007\u0003"+ - "\u0000\u15fa\u15fb\u0003!\u0010\u0000\u15fb\u15fc\u0003\u0013\t\u0000"+ - "\u15fc\u15fd\u0003\u000f\u0007\u0000\u15fd\u03b6\u0001\u0000\u0000\u0000"+ - "\u15fe\u15ff\u0003)\u0014\u0000\u15ff\u1600\u0003\u0007\u0003\u0000\u1600"+ - "\u1601\u0003!\u0010\u0000\u1601\u1602\u0003\u001b\r\u0000\u1602\u03b8"+ - "\u0001\u0000\u0000\u0000\u1603\u1604\u0003)\u0014\u0000\u1604\u1605\u0003"+ - "\u000f\u0007\u0000\u1605\u1606\u0003\u0007\u0003\u0000\u1606\u1607\u0003"+ - "\r\u0006\u0000\u1607\u03ba\u0001\u0000\u0000\u0000\u1608\u1609\u0003)"+ - "\u0014\u0000\u1609\u160a\u0003\u000f\u0007\u0000\u160a\u160b\u0003\u0007"+ - "\u0003\u0000\u160b\u160c\u0003\r\u0006\u0000\u160c\u160d\u0003+\u0015"+ - "\u0000\u160d\u03bc\u0001\u0000\u0000\u0000\u160e\u160f\u0003)\u0014\u0000"+ - "\u160f\u1610\u0003\u000f\u0007\u0000\u1610\u1611\u0003\u0007\u0003\u0000"+ - "\u1611\u1612\u0003\u001d\u000e\u0000\u1612\u03be\u0001\u0000\u0000\u0000"+ - "\u1613\u1614\u0003)\u0014\u0000\u1614\u1615\u0003\u000f\u0007\u0000\u1615"+ - "\u1616\u0003\u0007\u0003\u0000\u1616\u1617\u0003+\u0015\u0000\u1617\u1618"+ - "\u0003+\u0015\u0000\u1618\u1619\u0003\u0017\u000b\u0000\u1619\u161a\u0003"+ - "\u0013\t\u0000\u161a\u161b\u0003!\u0010\u0000\u161b\u03c0\u0001\u0000"+ - "\u0000\u0000\u161c\u161d\u0003)\u0014\u0000\u161d\u161e\u0003\u000f\u0007"+ - "\u0000\u161e\u161f\u0003\u000b\u0005\u0000\u161f\u1620\u0003\u0015\n\u0000"+ - "\u1620\u1621\u0003\u000f\u0007\u0000\u1621\u1622\u0003\u000b\u0005\u0000"+ - "\u1622\u1623\u0003\u001b\r\u0000\u1623\u03c2\u0001\u0000\u0000\u0000\u1624"+ - "\u1625\u0003)\u0014\u0000\u1625\u1626\u0003\u000f\u0007\u0000\u1626\u1627"+ - "\u0003\u000b\u0005\u0000\u1627\u1628\u0003/\u0017\u0000\u1628\u1629\u0003"+ - ")\u0014\u0000\u1629\u162a\u0003+\u0015\u0000\u162a\u162b\u0003\u0017\u000b"+ - "\u0000\u162b\u162c\u00031\u0018\u0000\u162c\u162d\u0003\u000f\u0007\u0000"+ - "\u162d\u03c4\u0001\u0000\u0000\u0000\u162e\u162f\u0003)\u0014\u0000\u162f"+ - "\u1630\u0003\u000f\u0007\u0000\u1630\u1631\u0003\u0011\b\u0000\u1631\u03c6"+ - "\u0001\u0000\u0000\u0000\u1632\u1633\u0003)\u0014\u0000\u1633\u1634\u0003"+ - "\u000f\u0007\u0000\u1634\u1635\u0003\u0011\b\u0000\u1635\u1636\u0003\u000f"+ - "\u0007\u0000\u1636\u1637\u0003)\u0014\u0000\u1637\u1638\u0003\u000f\u0007"+ - "\u0000\u1638\u1639\u0003!\u0010\u0000\u1639\u163a\u0003\u000b\u0005\u0000"+ - "\u163a\u163b\u0003\u000f\u0007\u0000\u163b\u163c\u0003+\u0015\u0000\u163c"+ - "\u03c8\u0001\u0000\u0000\u0000\u163d\u163e\u0003)\u0014\u0000\u163e\u163f"+ - "\u0003\u000f\u0007\u0000\u163f\u1640\u0003\u0011\b\u0000\u1640\u1641\u0003"+ - "\u000f\u0007\u0000\u1641\u1642\u0003)\u0014\u0000\u1642\u1643\u0003\u000f"+ - "\u0007\u0000\u1643\u1644\u0003!\u0010\u0000\u1644\u1645\u0003\u000b\u0005"+ - "\u0000\u1645\u1646\u0003\u0017\u000b\u0000\u1646\u1647\u0003!\u0010\u0000"+ - "\u1647\u1648\u0003\u0013\t\u0000\u1648\u03ca\u0001\u0000\u0000\u0000\u1649"+ - "\u164a\u0003)\u0014\u0000\u164a\u164b\u0003\u000f\u0007\u0000\u164b\u164c"+ - "\u0003\u0011\b\u0000\u164c\u164d\u0003)\u0014\u0000\u164d\u164e\u0003"+ - "\u000f\u0007\u0000\u164e\u164f\u0003+\u0015\u0000\u164f\u1650\u0003\u0015"+ - "\n\u0000\u1650\u03cc\u0001\u0000\u0000\u0000\u1651\u1652\u0003)\u0014"+ - "\u0000\u1652\u1653\u0003\u000f\u0007\u0000\u1653\u1654\u0003\u0013\t\u0000"+ - "\u1654\u1655\u0003)\u0014\u0000\u1655\u1656\u0005_\u0000\u0000\u1656\u1657"+ - "\u0003\u0007\u0003\u0000\u1657\u1658\u00031\u0018\u0000\u1658\u1659\u0003"+ - "\u0013\t\u0000\u1659\u165a\u00035\u001a\u0000\u165a\u03ce\u0001\u0000"+ - "\u0000\u0000\u165b\u165c\u0003)\u0014\u0000\u165c\u165d\u0003\u000f\u0007"+ - "\u0000\u165d\u165e\u0003\u0013\t\u0000\u165e\u165f\u0003)\u0014\u0000"+ - "\u165f\u1660\u0005_\u0000\u0000\u1660\u1661\u0003\u0007\u0003\u0000\u1661"+ - "\u1662\u00031\u0018\u0000\u1662\u1663\u0003\u0013\t\u0000\u1663\u1664"+ - "\u00037\u001b\u0000\u1664\u03d0\u0001\u0000\u0000\u0000\u1665\u1666\u0003"+ - ")\u0014\u0000\u1666\u1667\u0003\u000f\u0007\u0000\u1667\u1668\u0003\u0013"+ - "\t\u0000\u1668\u1669\u0003)\u0014\u0000\u1669\u166a\u0005_\u0000\u0000"+ - "\u166a\u166b\u0003\u000b\u0005\u0000\u166b\u166c\u0003#\u0011\u0000\u166c"+ - "\u166d\u0003/\u0017\u0000\u166d\u166e\u0003!\u0010\u0000\u166e\u166f\u0003"+ - "-\u0016\u0000\u166f\u03d2\u0001\u0000\u0000\u0000\u1670\u1671\u0003)\u0014"+ - "\u0000\u1671\u1672\u0003\u000f\u0007\u0000\u1672\u1673\u0003\u0013\t\u0000"+ - "\u1673\u1674\u0003)\u0014\u0000\u1674\u1675\u0005_\u0000\u0000\u1675\u1676"+ - "\u0003\u0017\u000b\u0000\u1676\u1677\u0003!\u0010\u0000\u1677\u1678\u0003"+ - "-\u0016\u0000\u1678\u1679\u0003\u000f\u0007\u0000\u1679\u167a\u0003)\u0014"+ - "\u0000\u167a\u167b\u0003\u000b\u0005\u0000\u167b\u167c\u0003\u000f\u0007"+ - "\u0000\u167c\u167d\u0003%\u0012\u0000\u167d\u167e\u0003-\u0016\u0000\u167e"+ - "\u03d4\u0001\u0000\u0000\u0000\u167f\u1680\u0003)\u0014\u0000\u1680\u1681"+ - "\u0003\u000f\u0007\u0000\u1681\u1682\u0003\u0013\t\u0000\u1682\u1683\u0003"+ - ")\u0014\u0000\u1683\u1684\u0005_\u0000\u0000\u1684\u1685\u0003)\u0014"+ - "\u0000\u1685\u1686\u00052\u0000\u0000\u1686\u03d6\u0001\u0000\u0000\u0000"+ - "\u1687\u1688\u0003)\u0014\u0000\u1688\u1689\u0003\u000f\u0007\u0000\u1689"+ - "\u168a\u0003\u0013\t\u0000\u168a\u168b\u0003)\u0014\u0000\u168b\u168c"+ - "\u0005_\u0000\u0000\u168c\u168d\u0003+\u0015\u0000\u168d\u168e\u0003\u001d"+ - "\u000e\u0000\u168e\u168f\u0003#\u0011\u0000\u168f\u1690\u0003%\u0012\u0000"+ - "\u1690\u1691\u0003\u000f\u0007\u0000\u1691\u03d8\u0001\u0000\u0000\u0000"+ - "\u1692\u1693\u0003)\u0014\u0000\u1693\u1694\u0003\u000f\u0007\u0000\u1694"+ - "\u1695\u0003\u0013\t\u0000\u1695\u1696\u0003)\u0014\u0000\u1696\u1697"+ - "\u0005_\u0000\u0000\u1697\u1698\u0003+\u0015\u0000\u1698\u1699\u00035"+ - "\u001a\u0000\u1699\u169a\u00035\u001a\u0000\u169a\u03da\u0001\u0000\u0000"+ - "\u0000\u169b\u169c\u0003)\u0014\u0000\u169c\u169d\u0003\u000f\u0007\u0000"+ - "\u169d\u169e\u0003\u0013\t\u0000\u169e\u169f\u0003)\u0014\u0000\u169f"+ - "\u16a0\u0005_\u0000\u0000\u16a0\u16a1\u0003+\u0015\u0000\u16a1\u16a2\u0003"+ - "5\u001a\u0000\u16a2\u16a3\u00037\u001b\u0000\u16a3\u03dc\u0001\u0000\u0000"+ - "\u0000\u16a4\u16a5\u0003)\u0014\u0000\u16a5\u16a6\u0003\u000f\u0007\u0000"+ - "\u16a6\u16a7\u0003\u0013\t\u0000\u16a7\u16a8\u0003)\u0014\u0000\u16a8"+ - "\u16a9\u0005_\u0000\u0000\u16a9\u16aa\u0003+\u0015\u0000\u16aa\u16ab\u0003"+ - "7\u001b\u0000\u16ab\u16ac\u00037\u001b\u0000\u16ac\u03de\u0001\u0000\u0000"+ - "\u0000\u16ad\u16ae\u0003)\u0014\u0000\u16ae\u16af\u0003\u000f\u0007\u0000"+ - "\u16af\u16b0\u0003\u0017\u000b\u0000\u16b0\u16b1\u0003!\u0010\u0000\u16b1"+ - "\u16b2\u0003\r\u0006\u0000\u16b2\u16b3\u0003\u000f\u0007\u0000\u16b3\u16b4"+ - "\u00035\u001a\u0000\u16b4\u03e0\u0001\u0000\u0000\u0000\u16b5\u16b6\u0003"+ - ")\u0014\u0000\u16b6\u16b7\u0003\u000f\u0007\u0000\u16b7\u16b8\u0003\u001d"+ - "\u000e\u0000\u16b8\u16b9\u0003\u0007\u0003\u0000\u16b9\u16ba\u0003-\u0016"+ - "\u0000\u16ba\u16bb\u0003\u0017\u000b\u0000\u16bb\u16bc\u00031\u0018\u0000"+ - "\u16bc\u16bd\u0003\u000f\u0007\u0000\u16bd\u03e2\u0001\u0000\u0000\u0000"+ - "\u16be\u16bf\u0003)\u0014\u0000\u16bf\u16c0\u0003\u000f\u0007\u0000\u16c0"+ - "\u16c1\u0003\u001d\u000e\u0000\u16c1\u16c2\u0003\u000f\u0007\u0000\u16c2"+ - "\u16c3\u0003\u0007\u0003\u0000\u16c3\u16c4\u0003+\u0015\u0000\u16c4\u16c5"+ - "\u0003\u000f\u0007\u0000\u16c5\u03e4\u0001\u0000\u0000\u0000\u16c6\u16c7"+ - "\u0003)\u0014\u0000\u16c7\u16c8\u0003\u000f\u0007\u0000\u16c8\u16c9\u0003"+ - "!\u0010\u0000\u16c9\u16ca\u0003\u0007\u0003\u0000\u16ca\u16cb\u0003\u001f"+ - "\u000f\u0000\u16cb\u16cc\u0003\u000f\u0007\u0000\u16cc\u03e6\u0001\u0000"+ - "\u0000\u0000\u16cd\u16ce\u0003)\u0014\u0000\u16ce\u16cf\u0003\u000f\u0007"+ - "\u0000\u16cf\u16d0\u0003%\u0012\u0000\u16d0\u16d1\u0003\u000f\u0007\u0000"+ - "\u16d1\u16d2\u0003\u0007\u0003\u0000\u16d2\u16d3\u0003-\u0016\u0000\u16d3"+ - "\u16d4\u0003\u0007\u0003\u0000\u16d4\u16d5\u0003\t\u0004\u0000\u16d5\u16d6"+ - "\u0003\u001d\u000e\u0000\u16d6\u16d7\u0003\u000f\u0007\u0000\u16d7\u03e8"+ - "\u0001\u0000\u0000\u0000\u16d8\u16d9\u0003)\u0014\u0000\u16d9\u16da\u0003"+ - "\u000f\u0007\u0000\u16da\u16db\u0003%\u0012\u0000\u16db\u16dc\u0003\u001d"+ - "\u000e\u0000\u16dc\u16dd\u0003\u0007\u0003\u0000\u16dd\u16de\u0003\u000b"+ - "\u0005\u0000\u16de\u16df\u0003\u000f\u0007\u0000\u16df\u03ea\u0001\u0000"+ - "\u0000\u0000\u16e0\u16e1\u0003)\u0014\u0000\u16e1\u16e2\u0003\u000f\u0007"+ - "\u0000\u16e2\u16e3\u0003%\u0012\u0000\u16e3\u16e4\u0003\u001d\u000e\u0000"+ - "\u16e4\u16e5\u0003\u0017\u000b\u0000\u16e5\u16e6\u0003\u000b\u0005\u0000"+ - "\u16e6\u16e7\u0003\u0007\u0003\u0000\u16e7\u03ec\u0001\u0000\u0000\u0000"+ - "\u16e8\u16e9\u0003)\u0014\u0000\u16e9\u16ea\u0003\u000f\u0007\u0000\u16ea"+ - "\u16eb\u0003+\u0015\u0000\u16eb\u16ec\u0003\u000f\u0007\u0000\u16ec\u16ed"+ - "\u0003-\u0016\u0000\u16ed\u03ee\u0001\u0000\u0000\u0000\u16ee\u16ef\u0003"+ - ")\u0014\u0000\u16ef\u16f0\u0003\u000f\u0007\u0000\u16f0\u16f1\u0003+\u0015"+ - "\u0000\u16f1\u16f2\u0003-\u0016\u0000\u16f2\u16f3\u0003\u0007\u0003\u0000"+ - "\u16f3\u16f4\u0003)\u0014\u0000\u16f4\u16f5\u0003-\u0016\u0000\u16f5\u03f0"+ - "\u0001\u0000\u0000\u0000\u16f6\u16f7\u0003)\u0014\u0000\u16f7\u16f8\u0003"+ - "\u000f\u0007\u0000\u16f8\u16f9\u0003+\u0015\u0000\u16f9\u16fa\u0003-\u0016"+ - "\u0000\u16fa\u16fb\u0003)\u0014\u0000\u16fb\u16fc\u0003\u0017\u000b\u0000"+ - "\u16fc\u16fd\u0003\u000b\u0005\u0000\u16fd\u16fe\u0003-\u0016\u0000\u16fe"+ - "\u03f2\u0001\u0000\u0000\u0000\u16ff\u1700\u0003)\u0014\u0000\u1700\u1701"+ - "\u0003\u000f\u0007\u0000\u1701\u1702\u0003+\u0015\u0000\u1702\u1703\u0003"+ - "/\u0017\u0000\u1703\u1704\u0003\u001d\u000e\u0000\u1704\u1705\u0003-\u0016"+ - "\u0000\u1705\u03f4\u0001\u0000\u0000\u0000\u1706\u1707\u0003)\u0014\u0000"+ - "\u1707\u1708\u0003\u000f\u0007\u0000\u1708\u1709\u0003-\u0016\u0000\u1709"+ - "\u170a\u0003/\u0017\u0000\u170a\u170b\u0003)\u0014\u0000\u170b\u170c\u0003"+ - "!\u0010\u0000\u170c\u03f6\u0001\u0000\u0000\u0000\u170d\u170e\u0003)\u0014"+ - "\u0000\u170e\u170f\u0003\u000f\u0007\u0000\u170f\u1710\u0003-\u0016\u0000"+ - "\u1710\u1711\u0003/\u0017\u0000\u1711\u1712\u0003)\u0014\u0000\u1712\u1713"+ - "\u0003!\u0010\u0000\u1713\u1714\u0003\u000f\u0007\u0000\u1714\u1715\u0003"+ - "\r\u0006\u0000\u1715\u1716\u0005_\u0000\u0000\u1716\u1717\u0003\u000b"+ - "\u0005\u0000\u1717\u1718\u0003\u0007\u0003\u0000\u1718\u1719\u0003)\u0014"+ - "\u0000\u1719\u171a\u0003\r\u0006\u0000\u171a\u171b\u0003\u0017\u000b\u0000"+ - "\u171b\u171c\u0003!\u0010\u0000\u171c\u171d\u0003\u0007\u0003\u0000\u171d"+ - "\u171e\u0003\u001d\u000e\u0000\u171e\u171f\u0003\u0017\u000b\u0000\u171f"+ - "\u1720\u0003-\u0016\u0000\u1720\u1721\u00037\u001b\u0000\u1721\u03f8\u0001"+ - "\u0000\u0000\u0000\u1722\u1723\u0003)\u0014\u0000\u1723\u1724\u0003\u000f"+ - "\u0007\u0000\u1724\u1725\u0003-\u0016\u0000\u1725\u1726\u0003/\u0017\u0000"+ - "\u1726\u1727\u0003)\u0014\u0000\u1727\u1728\u0003!\u0010\u0000\u1728\u1729"+ - "\u0003\u000f\u0007\u0000\u1729\u172a\u0003\r\u0006\u0000\u172a\u172b\u0005"+ - "_\u0000\u0000\u172b\u172c\u0003\u001d\u000e\u0000\u172c\u172d\u0003\u000f"+ - "\u0007\u0000\u172d\u172e\u0003!\u0010\u0000\u172e\u172f\u0003\u0013\t"+ - "\u0000\u172f\u1730\u0003-\u0016\u0000\u1730\u1731\u0003\u0015\n\u0000"+ - "\u1731\u03fa\u0001\u0000\u0000\u0000\u1732\u1733\u0003)\u0014\u0000\u1733"+ - "\u1734\u0003\u000f\u0007\u0000\u1734\u1735\u0003-\u0016\u0000\u1735\u1736"+ - "\u0003/\u0017\u0000\u1736\u1737\u0003)\u0014\u0000\u1737\u1738\u0003!"+ - "\u0010\u0000\u1738\u1739\u0003\u000f\u0007\u0000\u1739\u173a\u0003\r\u0006"+ - "\u0000\u173a\u173b\u0005_\u0000\u0000\u173b\u173c\u0003#\u0011\u0000\u173c"+ - "\u173d\u0003\u000b\u0005\u0000\u173d\u173e\u0003-\u0016\u0000\u173e\u173f"+ - "\u0003\u000f\u0007\u0000\u173f\u1740\u0003-\u0016\u0000\u1740\u1741\u0005"+ - "_\u0000\u0000\u1741\u1742\u0003\u001d\u000e\u0000\u1742\u1743\u0003\u000f"+ - "\u0007\u0000\u1743\u1744\u0003!\u0010\u0000\u1744\u1745\u0003\u0013\t"+ - "\u0000\u1745\u1746\u0003-\u0016\u0000\u1746\u1747\u0003\u0015\n\u0000"+ - "\u1747\u03fc\u0001\u0000\u0000\u0000\u1748\u1749\u0003)\u0014\u0000\u1749"+ - "\u174a\u0003\u000f\u0007\u0000\u174a\u174b\u0003-\u0016\u0000\u174b\u174c"+ - "\u0003/\u0017\u0000\u174c\u174d\u0003)\u0014\u0000\u174d\u174e\u0003!"+ - "\u0010\u0000\u174e\u174f\u0003\u000f\u0007\u0000\u174f\u1750\u0003\r\u0006"+ - "\u0000\u1750\u1751\u0005_\u0000\u0000\u1751\u1752\u0003+\u0015\u0000\u1752"+ - "\u1753\u0003\'\u0013\u0000\u1753\u1754\u0003\u001d\u000e\u0000\u1754\u1755"+ - "\u0003+\u0015\u0000\u1755\u1756\u0003-\u0016\u0000\u1756\u1757\u0003\u0007"+ - "\u0003\u0000\u1757\u1758\u0003-\u0016\u0000\u1758\u1759\u0003\u000f\u0007"+ - "\u0000\u1759\u03fe\u0001\u0000\u0000\u0000\u175a\u175b\u0003)\u0014\u0000"+ - "\u175b\u175c\u0003\u000f\u0007\u0000\u175c\u175d\u0003-\u0016\u0000\u175d"+ - "\u175e\u0003/\u0017\u0000\u175e\u175f\u0003)\u0014\u0000\u175f\u1760\u0003"+ - "!\u0010\u0000\u1760\u1761\u0003\u0017\u000b\u0000\u1761\u1762\u0003!\u0010"+ - "\u0000\u1762\u1763\u0003\u0013\t\u0000\u1763\u0400\u0001\u0000\u0000\u0000"+ - "\u1764\u1765\u0003)\u0014\u0000\u1765\u1766\u0003\u000f\u0007\u0000\u1766"+ - "\u1767\u0003-\u0016\u0000\u1767\u1768\u0003/\u0017\u0000\u1768\u1769\u0003"+ - ")\u0014\u0000\u1769\u176a\u0003!\u0010\u0000\u176a\u176b\u0003+\u0015"+ - "\u0000\u176b\u0402\u0001\u0000\u0000\u0000\u176c\u176d\u0003)\u0014\u0000"+ - "\u176d\u176e\u0003\u000f\u0007\u0000\u176e\u176f\u00031\u0018\u0000\u176f"+ - "\u1770\u0003#\u0011\u0000\u1770\u1771\u0003\u001b\r\u0000\u1771\u1772"+ - "\u0003\u000f\u0007\u0000\u1772\u0404\u0001\u0000\u0000\u0000\u1773\u1774"+ - "\u0003)\u0014\u0000\u1774\u1775\u0003\u0017\u000b\u0000\u1775\u1776\u0003"+ - "\u0013\t\u0000\u1776\u1777\u0003\u0015\n\u0000\u1777\u1778\u0003-\u0016"+ - "\u0000\u1778\u0406\u0001\u0000\u0000\u0000\u1779\u177a\u0003)\u0014\u0000"+ - "\u177a\u177b\u0003#\u0011\u0000\u177b\u177c\u0003\u001d\u000e\u0000\u177c"+ - "\u177d\u0003\u000f\u0007\u0000\u177d\u0408\u0001\u0000\u0000\u0000\u177e"+ - "\u177f\u0003)\u0014\u0000\u177f\u1780\u0003#\u0011\u0000\u1780\u1781\u0003"+ - "\u001d\u000e\u0000\u1781\u1782\u0003\u001d\u000e\u0000\u1782\u1783\u0003"+ - "\t\u0004\u0000\u1783\u1784\u0003\u0007\u0003\u0000\u1784\u1785\u0003\u000b"+ - "\u0005\u0000\u1785\u1786\u0003\u001b\r\u0000\u1786\u040a\u0001\u0000\u0000"+ - "\u0000\u1787\u1788\u0003)\u0014\u0000\u1788\u1789\u0003#\u0011\u0000\u1789"+ - "\u178a\u0003\u001d\u000e\u0000\u178a\u178b\u0003\u001d\u000e\u0000\u178b"+ - "\u178c\u0003/\u0017\u0000\u178c\u178d\u0003%\u0012\u0000\u178d\u040c\u0001"+ - "\u0000\u0000\u0000\u178e\u178f\u0003)\u0014\u0000\u178f\u1790\u0003#\u0011"+ - "\u0000\u1790\u1791\u0003/\u0017\u0000\u1791\u1792\u0003-\u0016\u0000\u1792"+ - "\u1793\u0003\u0017\u000b\u0000\u1793\u1794\u0003!\u0010\u0000\u1794\u1795"+ - "\u0003\u000f\u0007\u0000\u1795\u040e\u0001\u0000\u0000\u0000\u1796\u1797"+ - "\u0003)\u0014\u0000\u1797\u1798\u0003#\u0011\u0000\u1798\u1799\u0003/"+ - "\u0017\u0000\u1799\u179a\u0003-\u0016\u0000\u179a\u179b\u0003\u0017\u000b"+ - "\u0000\u179b\u179c\u0003!\u0010\u0000\u179c\u179d\u0003\u000f\u0007\u0000"+ - "\u179d\u179e\u0005_\u0000\u0000\u179e\u179f\u0003\u000b\u0005\u0000\u179f"+ - "\u17a0\u0003\u0007\u0003\u0000\u17a0\u17a1\u0003-\u0016\u0000\u17a1\u17a2"+ - "\u0003\u0007\u0003\u0000\u17a2\u17a3\u0003\u001d\u000e\u0000\u17a3\u17a4"+ - "\u0003#\u0011\u0000\u17a4\u17a5\u0003\u0013\t\u0000\u17a5\u0410\u0001"+ - "\u0000\u0000\u0000\u17a6\u17a7\u0003)\u0014\u0000\u17a7\u17a8\u0003#\u0011"+ - "\u0000\u17a8\u17a9\u0003/\u0017\u0000\u17a9\u17aa\u0003-\u0016\u0000\u17aa"+ - "\u17ab\u0003\u0017\u000b\u0000\u17ab\u17ac\u0003!\u0010\u0000\u17ac\u17ad"+ - "\u0003\u000f\u0007\u0000\u17ad\u17ae\u0005_\u0000\u0000\u17ae\u17af\u0003"+ - "!\u0010\u0000\u17af\u17b0\u0003\u0007\u0003\u0000\u17b0\u17b1\u0003\u001f"+ - "\u000f\u0000\u17b1\u17b2\u0003\u000f\u0007\u0000\u17b2\u0412\u0001\u0000"+ - "\u0000\u0000\u17b3\u17b4\u0003)\u0014\u0000\u17b4\u17b5\u0003#\u0011\u0000"+ - "\u17b5\u17b6\u0003/\u0017\u0000\u17b6\u17b7\u0003-\u0016\u0000\u17b7\u17b8"+ - "\u0003\u0017\u000b\u0000\u17b8\u17b9\u0003!\u0010\u0000\u17b9\u17ba\u0003"+ - "\u000f\u0007\u0000\u17ba\u17bb\u0005_\u0000\u0000\u17bb\u17bc\u0003+\u0015"+ - "\u0000\u17bc\u17bd\u0003\u000b\u0005\u0000\u17bd\u17be\u0003\u0015\n\u0000"+ - "\u17be\u17bf\u0003\u000f\u0007\u0000\u17bf\u17c0\u0003\u001f\u000f\u0000"+ - "\u17c0\u17c1\u0003\u0007\u0003\u0000\u17c1\u0414\u0001\u0000\u0000\u0000"+ - "\u17c2\u17c3\u0003)\u0014\u0000\u17c3\u17c4\u0003#\u0011\u0000\u17c4\u17c5"+ - "\u00033\u0019\u0000\u17c5\u0416\u0001\u0000\u0000\u0000\u17c6\u17c7\u0003"+ - ")\u0014\u0000\u17c7\u17c8\u0003#\u0011\u0000\u17c8\u17c9\u00033\u0019"+ - "\u0000\u17c9\u17ca\u0005_\u0000\u0000\u17ca\u17cb\u0003\u000b\u0005\u0000"+ - "\u17cb\u17cc\u0003#\u0011\u0000\u17cc\u17cd\u0003/\u0017\u0000\u17cd\u17ce"+ - "\u0003!\u0010\u0000\u17ce\u17cf\u0003-\u0016\u0000\u17cf\u0418\u0001\u0000"+ - "\u0000\u0000\u17d0\u17d1\u0003)\u0014\u0000\u17d1\u17d2\u0003#\u0011\u0000"+ - "\u17d2\u17d3\u00033\u0019\u0000\u17d3\u17d4\u0005_\u0000\u0000\u17d4\u17d5"+ - "\u0003!\u0010\u0000\u17d5\u17d6\u0003/\u0017\u0000\u17d6\u17d7\u0003\u001f"+ - "\u000f\u0000\u17d7\u17d8\u0003\t\u0004\u0000\u17d8\u17d9\u0003\u000f\u0007"+ - "\u0000\u17d9\u17da\u0003)\u0014\u0000\u17da\u041a\u0001\u0000\u0000\u0000"+ - "\u17db\u17dc\u0003)\u0014\u0000\u17dc\u17dd\u0003#\u0011\u0000\u17dd\u17de"+ - "\u00033\u0019\u0000\u17de\u17df\u0003+\u0015\u0000\u17df\u041c\u0001\u0000"+ - "\u0000\u0000\u17e0\u17e1\u0003)\u0014\u0000\u17e1\u17e2\u0003/\u0017\u0000"+ - "\u17e2\u17e3\u0003\u001d\u000e\u0000\u17e3\u17e4\u0003\u000f\u0007\u0000"+ - "\u17e4\u041e\u0001\u0000\u0000\u0000\u17e5\u17e6\u0003+\u0015\u0000\u17e6"+ - "\u17e7\u0003\u0007\u0003\u0000\u17e7\u17e8\u00031\u0018\u0000\u17e8\u17e9"+ - "\u0003\u000f\u0007\u0000\u17e9\u17ea\u0003%\u0012\u0000\u17ea\u17eb\u0003"+ - "#\u0011\u0000\u17eb\u17ec\u0003\u0017\u000b\u0000\u17ec\u17ed\u0003!\u0010"+ - "\u0000\u17ed\u17ee\u0003-\u0016\u0000\u17ee\u0420\u0001\u0000\u0000\u0000"+ - "\u17ef\u17f0\u0003+\u0015\u0000\u17f0\u17f1\u0003\u000b\u0005\u0000\u17f1"+ - "\u17f2\u0003\u0007\u0003\u0000\u17f2\u17f3\u0003\u001d\u000e\u0000\u17f3"+ - "\u17f4\u0003\u000f\u0007\u0000\u17f4\u0422\u0001\u0000\u0000\u0000\u17f5"+ - "\u17f6\u0003+\u0015\u0000\u17f6\u17f7\u0003\u000b\u0005\u0000\u17f7\u17f8"+ - "\u0003\u0015\n\u0000\u17f8\u17f9\u0003\u000f\u0007\u0000\u17f9\u17fa\u0003"+ - "\u001f\u000f\u0000\u17fa\u17fb\u0003\u0007\u0003\u0000\u17fb\u0424\u0001"+ - "\u0000\u0000\u0000\u17fc\u17fd\u0003+\u0015\u0000\u17fd\u17fe\u0003\u000b"+ - "\u0005\u0000\u17fe\u17ff\u0003\u0015\n\u0000\u17ff\u1800\u0003\u000f\u0007"+ - "\u0000\u1800\u1801\u0003\u001f\u000f\u0000\u1801\u1802\u0003\u0007\u0003"+ - "\u0000\u1802\u1803\u0005_\u0000\u0000\u1803\u1804\u0003!\u0010\u0000\u1804"+ - "\u1805\u0003\u0007\u0003\u0000\u1805\u1806\u0003\u001f\u000f\u0000\u1806"+ - "\u1807\u0003\u000f\u0007\u0000\u1807\u0426\u0001\u0000\u0000\u0000\u1808"+ - "\u1809\u0003+\u0015\u0000\u1809\u180a\u0003\u000b\u0005\u0000\u180a\u180b"+ - "\u0003#\u0011\u0000\u180b\u180c\u0003%\u0012\u0000\u180c\u180d\u0003\u000f"+ - "\u0007\u0000\u180d\u0428\u0001\u0000\u0000\u0000\u180e\u180f\u0003+\u0015"+ - "\u0000\u180f\u1810\u0003\u000b\u0005\u0000\u1810\u1811\u0003#\u0011\u0000"+ - "\u1811\u1812\u0003%\u0012\u0000\u1812\u1813\u0003\u000f\u0007\u0000\u1813"+ - "\u1814\u0005_\u0000\u0000\u1814\u1815\u0003\u000b\u0005\u0000\u1815\u1816"+ - "\u0003\u0007\u0003\u0000\u1816\u1817\u0003-\u0016\u0000\u1817\u1818\u0003"+ - "\u0007\u0003\u0000\u1818\u1819\u0003\u001d\u000e\u0000\u1819\u181a\u0003"+ - "#\u0011\u0000\u181a\u181b\u0003\u0013\t\u0000\u181b\u042a\u0001\u0000"+ - "\u0000\u0000\u181c\u181d\u0003+\u0015\u0000\u181d\u181e\u0003\u000b\u0005"+ - "\u0000\u181e\u181f\u0003#\u0011\u0000\u181f\u1820\u0003%\u0012\u0000\u1820"+ - "\u1821\u0003\u000f\u0007\u0000\u1821\u1822\u0005_\u0000\u0000\u1822\u1823"+ - "\u0003!\u0010\u0000\u1823\u1824\u0003\u0007\u0003\u0000\u1824\u1825\u0003"+ - "\u001f\u000f\u0000\u1825\u1826\u0003\u000f\u0007\u0000\u1826\u042c\u0001"+ - "\u0000\u0000\u0000\u1827\u1828\u0003+\u0015\u0000\u1828\u1829\u0003\u000b"+ - "\u0005\u0000\u1829\u182a\u0003#\u0011\u0000\u182a\u182b\u0003%\u0012\u0000"+ - "\u182b\u182c\u0003\u000f\u0007\u0000\u182c\u182d\u0005_\u0000\u0000\u182d"+ - "\u182e\u0003+\u0015\u0000\u182e\u182f\u0003\u000b\u0005\u0000\u182f\u1830"+ - "\u0003\u0015\n\u0000\u1830\u1831\u0003\u000f\u0007\u0000\u1831\u1832\u0003"+ - "\u001f\u000f\u0000\u1832\u1833\u0003\u0007\u0003\u0000\u1833\u042e\u0001"+ - "\u0000\u0000\u0000\u1834\u1835\u0003+\u0015\u0000\u1835\u1836\u0003\u000b"+ - "\u0005\u0000\u1836\u1837\u0003)\u0014\u0000\u1837\u1838\u0003#\u0011\u0000"+ - "\u1838\u1839\u0003\u001d\u000e\u0000\u1839\u183a\u0003\u001d\u000e\u0000"+ - "\u183a\u0430\u0001\u0000\u0000\u0000\u183b\u183c\u0003+\u0015\u0000\u183c"+ - "\u183d\u0003\u000f\u0007\u0000\u183d\u183e\u0003\u0007\u0003\u0000\u183e"+ - "\u183f\u0003)\u0014\u0000\u183f\u1840\u0003\u000b\u0005\u0000\u1840\u1841"+ - "\u0003\u0015\n\u0000\u1841\u0432\u0001\u0000\u0000\u0000\u1842\u1843\u0003"+ - "+\u0015\u0000\u1843\u1844\u0003\u000f\u0007\u0000\u1844\u1845\u0003\u000b"+ - "\u0005\u0000\u1845\u1846\u0003#\u0011\u0000\u1846\u1847\u0003!\u0010\u0000"+ - "\u1847\u1848\u0003\r\u0006\u0000\u1848\u0434\u0001\u0000\u0000\u0000\u1849"+ - "\u184a\u0003+\u0015\u0000\u184a\u184b\u0003\u000f\u0007\u0000\u184b\u184c"+ - "\u0003\u000b\u0005\u0000\u184c\u184d\u0003-\u0016\u0000\u184d\u184e\u0003"+ - "\u0017\u000b\u0000\u184e\u184f\u0003#\u0011\u0000\u184f\u1850\u0003!\u0010"+ - "\u0000\u1850\u0436\u0001\u0000\u0000\u0000\u1851\u1852\u0003+\u0015\u0000"+ - "\u1852\u1853\u0003\u000f\u0007\u0000\u1853\u1854\u0003\u000b\u0005\u0000"+ - "\u1854\u1855\u0003/\u0017\u0000\u1855\u1856\u0003)\u0014\u0000\u1856\u1857"+ - "\u0003\u0017\u000b\u0000\u1857\u1858\u0003-\u0016\u0000\u1858\u1859\u0003"+ - "7\u001b\u0000\u1859\u0438\u0001\u0000\u0000\u0000\u185a\u185b\u0003+\u0015"+ - "\u0000\u185b\u185c\u0003\u000f\u0007\u0000\u185c\u185d\u0003\u001d\u000e"+ - "\u0000\u185d\u185e\u0003\u000f\u0007\u0000\u185e\u185f\u0003\u000b\u0005"+ - "\u0000\u185f\u1860\u0003-\u0016\u0000\u1860\u043a\u0001\u0000\u0000\u0000"+ - "\u1861\u1862\u0003+\u0015\u0000\u1862\u1863\u0003\u000f\u0007\u0000\u1863"+ - "\u1864\u0003\u001d\u000e\u0000\u1864\u1865\u0003\u0011\b\u0000\u1865\u043c"+ - "\u0001\u0000\u0000\u0000\u1866\u1867\u0003+\u0015\u0000\u1867\u1868\u0003"+ - "\u000f\u0007\u0000\u1868\u1869\u0003!\u0010\u0000\u1869\u186a\u0003+\u0015"+ - "\u0000\u186a\u186b\u0003\u0017\u000b\u0000\u186b\u186c\u0003-\u0016\u0000"+ - "\u186c\u186d\u0003\u0017\u000b\u0000\u186d\u186e\u00031\u0018\u0000\u186e"+ - "\u186f\u0003\u000f\u0007\u0000\u186f\u043e\u0001\u0000\u0000\u0000\u1870"+ - "\u1871\u0003+\u0015\u0000\u1871\u1872\u0003\u000f\u0007\u0000\u1872\u1873"+ - "\u0003\'\u0013\u0000\u1873\u1874\u0003/\u0017\u0000\u1874\u1875\u0003"+ - "\u000f\u0007\u0000\u1875\u1876\u0003!\u0010\u0000\u1876\u1877\u0003\u000b"+ - "\u0005\u0000\u1877\u1878\u0003\u000f\u0007\u0000\u1878\u0440\u0001\u0000"+ - "\u0000\u0000\u1879\u187a\u0003+\u0015\u0000\u187a\u187b\u0003\u000f\u0007"+ - "\u0000\u187b\u187c\u0003\'\u0013\u0000\u187c\u187d\u0003/\u0017\u0000"+ - "\u187d\u187e\u0003\u000f\u0007\u0000\u187e\u187f\u0003!\u0010\u0000\u187f"+ - "\u1880\u0003\u000b\u0005\u0000\u1880\u1881\u0003\u000f\u0007\u0000\u1881"+ - "\u1882\u0003+\u0015\u0000\u1882\u0442\u0001\u0000\u0000\u0000\u1883\u1884"+ - "\u0003+\u0015\u0000\u1884\u1885\u0003\u000f\u0007\u0000\u1885\u1886\u0003"+ - ")\u0014\u0000\u1886\u1887\u0003\u0017\u000b\u0000\u1887\u1888\u0003\u0007"+ - "\u0003\u0000\u1888\u1889\u0003\u001d\u000e\u0000\u1889\u188a\u0003\u0017"+ - "\u000b\u0000\u188a\u188b\u00039\u001c\u0000\u188b\u188c\u0003\u0007\u0003"+ - "\u0000\u188c\u188d\u0003\t\u0004\u0000\u188d\u188e\u0003\u001d\u000e\u0000"+ - "\u188e\u188f\u0003\u000f\u0007\u0000\u188f\u0444\u0001\u0000\u0000\u0000"+ - "\u1890\u1891\u0003+\u0015\u0000\u1891\u1892\u0003\u000f\u0007\u0000\u1892"+ - "\u1893\u0003)\u0014\u0000\u1893\u1894\u00031\u0018\u0000\u1894\u1895\u0003"+ - "\u000f\u0007\u0000\u1895\u1896\u0003)\u0014\u0000\u1896\u1897\u0005_\u0000"+ - "\u0000\u1897\u1898\u0003!\u0010\u0000\u1898\u1899\u0003\u0007\u0003\u0000"+ - "\u1899\u189a\u0003\u001f\u000f\u0000\u189a\u189b\u0003\u000f\u0007\u0000"+ - "\u189b\u0446\u0001\u0000\u0000\u0000\u189c\u189d\u0003+\u0015\u0000\u189d"+ - "\u189e\u0003\u000f\u0007\u0000\u189e\u189f\u0003+\u0015\u0000\u189f\u18a0"+ - "\u0003+\u0015\u0000\u18a0\u18a1\u0003\u0017\u000b\u0000\u18a1\u18a2\u0003"+ - "#\u0011\u0000\u18a2\u18a3\u0003!\u0010\u0000\u18a3\u0448\u0001\u0000\u0000"+ - "\u0000\u18a4\u18a5\u0003+\u0015\u0000\u18a5\u18a6\u0003\u000f\u0007\u0000"+ - "\u18a6\u18a7\u0003+\u0015\u0000\u18a7\u18a8\u0003+\u0015\u0000\u18a8\u18a9"+ - "\u0003\u0017\u000b\u0000\u18a9\u18aa\u0003#\u0011\u0000\u18aa\u18ab\u0003"+ - "!\u0010\u0000\u18ab\u18ac\u0005_\u0000\u0000\u18ac\u18ad\u0003/\u0017"+ - "\u0000\u18ad\u18ae\u0003+\u0015\u0000\u18ae\u18af\u0003\u000f\u0007\u0000"+ - "\u18af\u18b0\u0003)\u0014\u0000\u18b0\u044a\u0001\u0000\u0000\u0000\u18b1"+ - "\u18b2\u0003+\u0015\u0000\u18b2\u18b3\u0003\u000f\u0007\u0000\u18b3\u18b4"+ - "\u0003-\u0016\u0000\u18b4\u044c\u0001\u0000\u0000\u0000\u18b5\u18b6\u0003"+ - "+\u0015\u0000\u18b6\u18b7\u0003\u000f\u0007\u0000\u18b7\u18b8\u0003-\u0016"+ - "\u0000\u18b8\u18b9\u0003#\u0011\u0000\u18b9\u18ba\u0003\u0011\b\u0000"+ - "\u18ba\u044e\u0001\u0000\u0000\u0000\u18bb\u18bc\u0003+\u0015\u0000\u18bc"+ - "\u18bd\u0003\u000f\u0007\u0000\u18bd\u18be\u0003-\u0016\u0000\u18be\u18bf"+ - "\u0003+\u0015\u0000\u18bf\u0450\u0001\u0000\u0000\u0000\u18c0\u18c1\u0003"+ - "+\u0015\u0000\u18c1\u18c2\u0003\u0015\n\u0000\u18c2\u18c3\u0003\u0007"+ - "\u0003\u0000\u18c3\u18c4\u0003)\u0014\u0000\u18c4\u18c5\u0003\u000f\u0007"+ - "\u0000\u18c5\u0452\u0001\u0000\u0000\u0000\u18c6\u18c7\u0003+\u0015\u0000"+ - "\u18c7\u18c8\u0003\u0015\n\u0000\u18c8\u18c9\u0003#\u0011\u0000\u18c9"+ - "\u18ca\u00033\u0019\u0000\u18ca\u0454\u0001\u0000\u0000\u0000\u18cb\u18cc"+ - "\u0003+\u0015\u0000\u18cc\u18cd\u0003\u0017\u000b\u0000\u18cd\u18ce\u0003"+ - "\u001f\u000f\u0000\u18ce\u18cf\u0003\u0017\u000b\u0000\u18cf\u18d0\u0003"+ - "\u001d\u000e\u0000\u18d0\u18d1\u0003\u0007\u0003\u0000\u18d1\u18d2\u0003"+ - ")\u0014\u0000\u18d2\u0456\u0001\u0000\u0000\u0000\u18d3\u18d4\u0003+\u0015"+ - "\u0000\u18d4\u18d5\u0003\u0017\u000b\u0000\u18d5\u18d6\u0003\u001f\u000f"+ - "\u0000\u18d6\u18d7\u0003%\u0012\u0000\u18d7\u18d8\u0003\u001d\u000e\u0000"+ - "\u18d8\u18d9\u0003\u000f\u0007\u0000\u18d9\u0458\u0001\u0000\u0000\u0000"+ - "\u18da\u18db\u0003+\u0015\u0000\u18db\u18dc\u0003\u0017\u000b\u0000\u18dc"+ - "\u18dd\u00039\u001c\u0000\u18dd\u18de\u0003\u000f\u0007\u0000\u18de\u045a"+ - "\u0001\u0000\u0000\u0000\u18df\u18e0\u0003+\u0015\u0000\u18e0\u18e1\u0003"+ - "\u001b\r\u0000\u18e1\u18e2\u0003\u0017\u000b\u0000\u18e2\u18e3\u0003%"+ - "\u0012\u0000\u18e3\u045c\u0001\u0000\u0000\u0000\u18e4\u18e5\u0003+\u0015"+ - "\u0000\u18e5\u18e6\u0003\u001f\u000f\u0000\u18e6\u18e7\u0003\u0007\u0003"+ - "\u0000\u18e7\u18e8\u0003\u001d\u000e\u0000\u18e8\u18e9\u0003\u001d\u000e"+ - "\u0000\u18e9\u18ea\u0003\u0017\u000b\u0000\u18ea\u18eb\u0003!\u0010\u0000"+ - "\u18eb\u18ec\u0003-\u0016\u0000\u18ec\u045e\u0001\u0000\u0000\u0000\u18ed"+ - "\u18ee\u0003+\u0015\u0000\u18ee\u18ef\u0003!\u0010\u0000\u18ef\u18f0\u0003"+ - "\u0007\u0003\u0000\u18f0\u18f1\u0003%\u0012\u0000\u18f1\u18f2\u0003+\u0015"+ - "\u0000\u18f2\u18f3\u0003\u0015\n\u0000\u18f3\u18f4\u0003#\u0011\u0000"+ - "\u18f4\u18f5\u0003-\u0016\u0000\u18f5\u0460\u0001\u0000\u0000\u0000\u18f6"+ - "\u18f7\u0003+\u0015\u0000\u18f7\u18f8\u0003#\u0011\u0000\u18f8\u18f9\u0003"+ - "\u001f\u000f\u0000\u18f9\u18fa\u0003\u000f\u0007\u0000\u18fa\u0462\u0001"+ - "\u0000\u0000\u0000\u18fb\u18fc\u0003+\u0015\u0000\u18fc\u18fd\u0003#\u0011"+ - "\u0000\u18fd\u18fe\u0003/\u0017\u0000\u18fe\u18ff\u0003)\u0014\u0000\u18ff"+ - "\u1900\u0003\u000b\u0005\u0000\u1900\u1901\u0003\u000f\u0007\u0000\u1901"+ - "\u0464\u0001\u0000\u0000\u0000\u1902\u1903\u0003+\u0015\u0000\u1903\u1904"+ - "\u0003%\u0012\u0000\u1904\u1905\u0003\u0007\u0003\u0000\u1905\u1906\u0003"+ - "\u000b\u0005\u0000\u1906\u1907\u0003\u000f\u0007\u0000\u1907\u0466\u0001"+ - "\u0000\u0000\u0000\u1908\u1909\u0003+\u0015\u0000\u1909\u190a\u0003%\u0012"+ - "\u0000\u190a\u190b\u0003\u000f\u0007\u0000\u190b\u190c\u0003\u000b\u0005"+ - "\u0000\u190c\u190d\u0003\u0017\u000b\u0000\u190d\u190e\u0003\u0011\b\u0000"+ - "\u190e\u190f\u0003\u0017\u000b\u0000\u190f\u1910\u0003\u000b\u0005\u0000"+ - "\u1910\u0468\u0001\u0000\u0000\u0000\u1911\u1912\u0003+\u0015\u0000\u1912"+ - "\u1913\u0003%\u0012\u0000\u1913\u1914\u0003\u000f\u0007\u0000\u1914\u1915"+ - "\u0003\u000b\u0005\u0000\u1915\u1916\u0003\u0017\u000b\u0000\u1916\u1917"+ - "\u0003\u0011\b\u0000\u1917\u1918\u0003\u0017\u000b\u0000\u1918\u1919\u0003"+ - "\u000b\u0005\u0000\u1919\u191a\u0005_\u0000\u0000\u191a\u191b\u0003!\u0010"+ - "\u0000\u191b\u191c\u0003\u0007\u0003\u0000\u191c\u191d\u0003\u001f\u000f"+ - "\u0000\u191d\u191e\u0003\u000f\u0007\u0000\u191e\u046a\u0001\u0000\u0000"+ - "\u0000\u191f\u1920\u0003+\u0015\u0000\u1920\u1921\u0003%\u0012\u0000\u1921"+ - "\u1922\u0003\u000f\u0007\u0000\u1922\u1923\u0003\u000b\u0005\u0000\u1923"+ - "\u1924\u0003\u0017\u000b\u0000\u1924\u1925\u0003\u0011\b\u0000\u1925\u1926"+ - "\u0003\u0017\u000b\u0000\u1926\u1927\u0003\u000b\u0005\u0000\u1927\u1928"+ - "\u0003-\u0016\u0000\u1928\u1929\u00037\u001b\u0000\u1929\u192a\u0003%"+ - "\u0012\u0000\u192a\u192b\u0003\u000f\u0007\u0000\u192b\u046c\u0001\u0000"+ - "\u0000\u0000\u192c\u192d\u0003+\u0015\u0000\u192d\u192e\u0003\'\u0013"+ - "\u0000\u192e\u192f\u0003\u001d\u000e\u0000\u192f\u046e\u0001\u0000\u0000"+ - "\u0000\u1930\u1931\u0003+\u0015\u0000\u1931\u1932\u0003\'\u0013\u0000"+ - "\u1932\u1933\u0003\u001d\u000e\u0000\u1933\u1934\u0003\u000b\u0005\u0000"+ - "\u1934\u1935\u0003#\u0011\u0000\u1935\u1936\u0003\r\u0006\u0000\u1936"+ - "\u1937\u0003\u000f\u0007\u0000\u1937\u0470\u0001\u0000\u0000\u0000\u1938"+ - "\u1939\u0003+\u0015\u0000\u1939\u193a\u0003\'\u0013\u0000\u193a\u193b"+ - "\u0003\u001d\u000e\u0000\u193b\u193c\u0003\u000f\u0007\u0000\u193c\u193d"+ - "\u0003)\u0014\u0000\u193d\u193e\u0003)\u0014\u0000\u193e\u193f\u0003#"+ - "\u0011\u0000\u193f\u1940\u0003)\u0014\u0000\u1940\u0472\u0001\u0000\u0000"+ - "\u0000\u1941\u1942\u0003+\u0015\u0000\u1942\u1943\u0003\'\u0013\u0000"+ - "\u1943\u1944\u0003\u001d\u000e\u0000\u1944\u1945\u0003\u000f\u0007\u0000"+ - "\u1945\u1946\u00035\u001a\u0000\u1946\u1947\u0003\u000b\u0005\u0000\u1947"+ - "\u1948\u0003\u000f\u0007\u0000\u1948\u1949\u0003%\u0012\u0000\u1949\u194a"+ - "\u0003-\u0016\u0000\u194a\u194b\u0003\u0017\u000b\u0000\u194b\u194c\u0003"+ - "#\u0011\u0000\u194c\u194d\u0003!\u0010\u0000\u194d\u0474\u0001\u0000\u0000"+ - "\u0000\u194e\u194f\u0003+\u0015\u0000\u194f\u1950\u0003\'\u0013\u0000"+ - "\u1950\u1951\u0003\u001d\u000e\u0000\u1951\u1952\u0003+\u0015\u0000\u1952"+ - "\u1953\u0003-\u0016\u0000\u1953\u1954\u0003\u0007\u0003\u0000\u1954\u1955"+ - "\u0003-\u0016\u0000\u1955\u1956\u0003\u000f\u0007\u0000\u1956\u0476\u0001"+ - "\u0000\u0000\u0000\u1957\u1958\u0003+\u0015\u0000\u1958\u1959\u0003\'"+ - "\u0013\u0000\u1959\u195a\u0003\u001d\u000e\u0000\u195a\u195b\u00033\u0019"+ - "\u0000\u195b\u195c\u0003\u0007\u0003\u0000\u195c\u195d\u0003)\u0014\u0000"+ - "\u195d\u195e\u0003!\u0010\u0000\u195e\u195f\u0003\u0017\u000b\u0000\u195f"+ - "\u1960\u0003!\u0010\u0000\u1960\u1961\u0003\u0013\t\u0000\u1961\u0478"+ - "\u0001\u0000\u0000\u0000\u1962\u1963\u0003+\u0015\u0000\u1963\u1964\u0003"+ - "\'\u0013\u0000\u1964\u1965\u0003)\u0014\u0000\u1965\u1966\u0003-\u0016"+ - "\u0000\u1966\u047a\u0001\u0000\u0000\u0000\u1967\u1968\u0003+\u0015\u0000"+ - "\u1968\u1969\u0003-\u0016\u0000\u1969\u196a\u0003\u0007\u0003\u0000\u196a"+ - "\u196b\u0003\t\u0004\u0000\u196b\u196c\u0003\u001d\u000e\u0000\u196c\u196d"+ - "\u0003\u000f\u0007\u0000\u196d\u047c\u0001\u0000\u0000\u0000\u196e\u196f"+ - "\u0003+\u0015\u0000\u196f\u1970\u0003-\u0016\u0000\u1970\u1971\u0003\u0007"+ - "\u0003\u0000\u1971\u1972\u0003)\u0014\u0000\u1972\u1973\u0003-\u0016\u0000"+ - "\u1973\u047e\u0001\u0000\u0000\u0000\u1974\u1975\u0003+\u0015\u0000\u1975"+ - "\u1976\u0003-\u0016\u0000\u1976\u1977\u0003\u0007\u0003\u0000\u1977\u1978"+ - "\u0003-\u0016\u0000\u1978\u1979\u0003\u000f\u0007\u0000\u1979\u0480\u0001"+ - "\u0000\u0000\u0000\u197a\u197b\u0003+\u0015\u0000\u197b\u197c\u0003-\u0016"+ - "\u0000\u197c\u197d\u0003\u0007\u0003\u0000\u197d\u197e\u0003-\u0016\u0000"+ - "\u197e\u197f\u0003\u000f\u0007\u0000\u197f\u1980\u0003\u001f\u000f\u0000"+ - "\u1980\u1981\u0003\u000f\u0007\u0000\u1981\u1982\u0003!\u0010\u0000\u1982"+ - "\u1983\u0003-\u0016\u0000\u1983\u0482\u0001\u0000\u0000\u0000\u1984\u1985"+ - "\u0003+\u0015\u0000\u1985\u1986\u0003-\u0016\u0000\u1986\u1987\u0003\u0007"+ - "\u0003\u0000\u1987\u1988\u0003-\u0016\u0000\u1988\u1989\u0003\u0017\u000b"+ - "\u0000\u1989\u198a\u0003\u000b\u0005\u0000\u198a\u0484\u0001\u0000\u0000"+ - "\u0000\u198b\u198c\u0003+\u0015\u0000\u198c\u198d\u0003-\u0016\u0000\u198d"+ - "\u198e\u0003\u0007\u0003\u0000\u198e\u198f\u0003-\u0016\u0000\u198f\u1990"+ - "\u0003\u0017\u000b\u0000\u1990\u1991\u0003+\u0015\u0000\u1991\u1992\u0003"+ - "-\u0016\u0000\u1992\u1993\u0003\u0017\u000b\u0000\u1993\u1994\u0003\u000b"+ - "\u0005\u0000\u1994\u1995\u0003+\u0015\u0000\u1995\u0486\u0001\u0000\u0000"+ - "\u0000\u1996\u1997\u0003+\u0015\u0000\u1997\u1998\u0003-\u0016\u0000\u1998"+ - "\u1999\u0003\r\u0006\u0000\u1999\u199a\u0003\r\u0006\u0000\u199a\u199b"+ - "\u0003\u000f\u0007\u0000\u199b\u199c\u00031\u0018\u0000\u199c\u199d\u0005"+ - "_\u0000\u0000\u199d\u199e\u0003%\u0012\u0000\u199e\u199f\u0003#\u0011"+ - "\u0000\u199f\u19a0\u0003%\u0012\u0000\u19a0\u0488\u0001\u0000\u0000\u0000"+ - "\u19a1\u19a2\u0003+\u0015\u0000\u19a2\u19a3\u0003-\u0016\u0000\u19a3\u19a4"+ - "\u0003\r\u0006\u0000\u19a4\u19a5\u0003\r\u0006\u0000\u19a5\u19a6\u0003"+ - "\u000f\u0007\u0000\u19a6\u19a7\u00031\u0018\u0000\u19a7\u19a8\u0005_\u0000"+ - "\u0000\u19a8\u19a9\u0003+\u0015\u0000\u19a9\u19aa\u0003\u0007\u0003\u0000"+ - "\u19aa\u19ab\u0003\u001f\u000f\u0000\u19ab\u19ac\u0003%\u0012\u0000\u19ac"+ - "\u048a\u0001\u0000\u0000\u0000\u19ad\u19ae\u0003+\u0015\u0000\u19ae\u19af"+ - "\u0003-\u0016\u0000\u19af\u19b0\u0003\r\u0006\u0000\u19b0\u19b1\u0003"+ - "\u0017\u000b\u0000\u19b1\u19b2\u0003!\u0010\u0000\u19b2\u048c\u0001\u0000"+ - "\u0000\u0000\u19b3\u19b4\u0003+\u0015\u0000\u19b4\u19b5\u0003-\u0016\u0000"+ - "\u19b5\u19b6\u0003\r\u0006\u0000\u19b6\u19b7\u0003#\u0011\u0000\u19b7"+ - "\u19b8\u0003/\u0017\u0000\u19b8\u19b9\u0003-\u0016\u0000\u19b9\u048e\u0001"+ - "\u0000\u0000\u0000\u19ba\u19bb\u0003+\u0015\u0000\u19bb\u19bc\u0003-\u0016"+ - "\u0000\u19bc\u19bd\u0003#\u0011\u0000\u19bd\u19be\u0003)\u0014\u0000\u19be"+ - "\u19bf\u0003\u0007\u0003\u0000\u19bf\u19c0\u0003\u0013\t\u0000\u19c0\u19c1"+ - "\u0003\u000f\u0007\u0000\u19c1\u0490\u0001\u0000\u0000\u0000\u19c2\u19c3"+ - "\u0003+\u0015\u0000\u19c3\u19c4\u0003-\u0016\u0000\u19c4\u19c5\u0003)"+ - "\u0014\u0000\u19c5\u19c6\u0003\u0017\u000b\u0000\u19c6\u19c7\u0003\u000b"+ - "\u0005\u0000\u19c7\u19c8\u0003-\u0016\u0000\u19c8\u0492\u0001\u0000\u0000"+ - "\u0000\u19c9\u19ca\u0003+\u0015\u0000\u19ca\u19cb\u0003-\u0016\u0000\u19cb"+ - "\u19cc\u0003)\u0014\u0000\u19cc\u19cd\u0003/\u0017\u0000\u19cd\u19ce\u0003"+ - "\u000b\u0005\u0000\u19ce\u19cf\u0003-\u0016\u0000\u19cf\u19d0\u0003/\u0017"+ - "\u0000\u19d0\u19d1\u0003)\u0014\u0000\u19d1\u19d2\u0003\u000f\u0007\u0000"+ - "\u19d2\u0494\u0001\u0000\u0000\u0000\u19d3\u19d4\u0003+\u0015\u0000\u19d4"+ - "\u19d5\u0003-\u0016\u0000\u19d5\u19d6\u00037\u001b\u0000\u19d6\u19d7\u0003"+ - "\u001d\u000e\u0000\u19d7\u19d8\u0003\u000f\u0007\u0000\u19d8\u0496\u0001"+ - "\u0000\u0000\u0000\u19d9\u19da\u0003+\u0015\u0000\u19da\u19db\u0003/\u0017"+ - "\u0000\u19db\u19dc\u0003\t\u0004\u0000\u19dc\u19dd\u0003\u000b\u0005\u0000"+ - "\u19dd\u19de\u0003\u001d\u000e\u0000\u19de\u19df\u0003\u0007\u0003\u0000"+ - "\u19df\u19e0\u0003+\u0015\u0000\u19e0\u19e1\u0003+\u0015\u0000\u19e1\u19e2"+ - "\u0005_\u0000\u0000\u19e2\u19e3\u0003#\u0011\u0000\u19e3\u19e4\u0003)"+ - "\u0014\u0000\u19e4\u19e5\u0003\u0017\u000b\u0000\u19e5\u19e6\u0003\u0013"+ - "\t\u0000\u19e6\u19e7\u0003\u0017\u000b\u0000\u19e7\u19e8\u0003!\u0010"+ - "\u0000\u19e8\u0498\u0001\u0000\u0000\u0000\u19e9\u19ea\u0003+\u0015\u0000"+ - "\u19ea\u19eb\u0003/\u0017\u0000\u19eb\u19ec\u0003\t\u0004\u0000\u19ec"+ - "\u19ed\u0003\u001d\u000e\u0000\u19ed\u19ee\u0003\u0017\u000b\u0000\u19ee"+ - "\u19ef\u0003+\u0015\u0000\u19ef\u19f0\u0003-\u0016\u0000\u19f0\u049a\u0001"+ - "\u0000\u0000\u0000\u19f1\u19f2\u0003+\u0015\u0000\u19f2\u19f3\u0003/\u0017"+ - "\u0000\u19f3\u19f4\u0003\t\u0004\u0000\u19f4\u19f5\u0003\u001f\u000f\u0000"+ - "\u19f5\u19f6\u0003/\u0017\u0000\u19f6\u19f7\u0003\u001d\u000e\u0000\u19f7"+ - "\u19f8\u0003-\u0016\u0000\u19f8\u19f9\u0003\u0017\u000b\u0000\u19f9\u19fa"+ - "\u0003+\u0015\u0000\u19fa\u19fb\u0003\u000f\u0007\u0000\u19fb\u19fc\u0003"+ - "-\u0016\u0000\u19fc\u049c\u0001\u0000\u0000\u0000\u19fd\u19fe\u0003+\u0015"+ - "\u0000\u19fe\u19ff\u0003/\u0017\u0000\u19ff\u1a00\u0003\t\u0004\u0000"+ - "\u1a00\u1a01\u0003+\u0015\u0000\u1a01\u1a02\u0003\u000b\u0005\u0000\u1a02"+ - "\u1a03\u0003)\u0014\u0000\u1a03\u1a04\u0003\u0017\u000b\u0000\u1a04\u1a05"+ - "\u0003%\u0012\u0000\u1a05\u1a06\u0003-\u0016\u0000\u1a06\u1a07\u0003\u0017"+ - "\u000b\u0000\u1a07\u1a08\u0003#\u0011\u0000\u1a08\u1a09\u0003!\u0010\u0000"+ - "\u1a09\u049e\u0001\u0000\u0000\u0000\u1a0a\u1a0b\u0003+\u0015\u0000\u1a0b"+ - "\u1a0c\u0003/\u0017\u0000\u1a0c\u1a0d\u0003\t\u0004\u0000\u1a0d\u1a0e"+ - "\u0003+\u0015\u0000\u1a0e\u1a0f\u0003-\u0016\u0000\u1a0f\u1a10\u0003)"+ - "\u0014\u0000\u1a10\u1a11\u0003\u0017\u000b\u0000\u1a11\u1a12\u0003!\u0010"+ - "\u0000\u1a12\u1a13\u0003\u0013\t\u0000\u1a13\u04a0\u0001\u0000\u0000\u0000"+ - "\u1a14\u1a15\u0003+\u0015\u0000\u1a15\u1a16\u0003/\u0017\u0000\u1a16\u1a17"+ - "\u0003\u001f\u000f\u0000\u1a17\u04a2\u0001\u0000\u0000\u0000\u1a18\u1a19"+ - "\u0003+\u0015\u0000\u1a19\u1a1a\u00037\u001b\u0000\u1a1a\u1a1b\u0003\u001f"+ - "\u000f\u0000\u1a1b\u1a1c\u0003\u001f\u000f\u0000\u1a1c\u1a1d\u0003\u000f"+ - "\u0007\u0000\u1a1d\u1a1e\u0003-\u0016\u0000\u1a1e\u1a1f\u0003)\u0014\u0000"+ - "\u1a1f\u1a20\u0003\u0017\u000b\u0000\u1a20\u1a21\u0003\u000b\u0005\u0000"+ - "\u1a21\u04a4\u0001\u0000\u0000\u0000\u1a22\u1a23\u0003+\u0015\u0000\u1a23"+ - "\u1a24\u00037\u001b\u0000\u1a24\u1a25\u0003+\u0015\u0000\u1a25\u1a26\u0003"+ - "\u0017\u000b\u0000\u1a26\u1a27\u0003\r\u0006\u0000\u1a27\u04a6\u0001\u0000"+ - "\u0000\u0000\u1a28\u1a29\u0003+\u0015\u0000\u1a29\u1a2a\u00037\u001b\u0000"+ - "\u1a2a\u1a2b\u0003+\u0015\u0000\u1a2b\u1a2c\u0003-\u0016\u0000\u1a2c\u1a2d"+ - "\u0003\u000f\u0007\u0000\u1a2d\u1a2e\u0003\u001f\u000f\u0000\u1a2e\u04a8"+ - "\u0001\u0000\u0000\u0000\u1a2f\u1a30\u0003+\u0015\u0000\u1a30\u1a31\u0003"+ - "7\u001b\u0000\u1a31\u1a32\u0003+\u0015\u0000\u1a32\u1a33\u0003-\u0016"+ - "\u0000\u1a33\u1a34\u0003\u000f\u0007\u0000\u1a34\u1a35\u0003\u001f\u000f"+ - "\u0000\u1a35\u1a36\u0005_\u0000\u0000\u1a36\u1a37\u0003/\u0017\u0000\u1a37"+ - "\u1a38\u0003+\u0015\u0000\u1a38\u1a39\u0003\u000f\u0007\u0000\u1a39\u1a3a"+ - "\u0003)\u0014\u0000\u1a3a\u04aa\u0001\u0000\u0000\u0000\u1a3b\u1a3c\u0003"+ - "-\u0016\u0000\u1a3c\u1a3d\u0003\u0007\u0003\u0000\u1a3d\u1a3e\u0003\t"+ - "\u0004\u0000\u1a3e\u1a3f\u0003\u001d\u000e\u0000\u1a3f\u1a40\u0003\u000f"+ - "\u0007\u0000\u1a40\u04ac\u0001\u0000\u0000\u0000\u1a41\u1a42\u0003-\u0016"+ - "\u0000\u1a42\u1a43\u0003\u0007\u0003\u0000\u1a43\u1a44\u0003\t\u0004\u0000"+ - "\u1a44\u1a45\u0003\u001d\u000e\u0000\u1a45\u1a46\u0003\u000f\u0007\u0000"+ - "\u1a46\u1a47\u0005_\u0000\u0000\u1a47\u1a48\u0003!\u0010\u0000\u1a48\u1a49"+ - "\u0003\u0007\u0003\u0000\u1a49\u1a4a\u0003\u001f\u000f\u0000\u1a4a\u1a4b"+ - "\u0003\u000f\u0007\u0000\u1a4b\u04ae\u0001\u0000\u0000\u0000\u1a4c\u1a4d"+ - "\u0003-\u0016\u0000\u1a4d\u1a4e\u0003\u0007\u0003\u0000\u1a4e\u1a4f\u0003"+ - "\t\u0004\u0000\u1a4f\u1a50\u0003\u001d\u000e\u0000\u1a50\u1a51\u0003\u000f"+ - "\u0007\u0000\u1a51\u1a52\u0003+\u0015\u0000\u1a52\u1a53\u0003\u0007\u0003"+ - "\u0000\u1a53\u1a54\u0003\u001f\u000f\u0000\u1a54\u1a55\u0003%\u0012\u0000"+ - "\u1a55\u1a56\u0003\u001d\u000e\u0000\u1a56\u1a57\u0003\u000f\u0007\u0000"+ - "\u1a57\u04b0\u0001\u0000\u0000\u0000\u1a58\u1a59\u0003-\u0016\u0000\u1a59"+ - "\u1a5a\u0003\u0007\u0003\u0000\u1a5a\u1a5b\u0003\t\u0004\u0000\u1a5b\u1a5c"+ - "\u0003\u001d\u000e\u0000\u1a5c\u1a5d\u0003\u000f\u0007\u0000\u1a5d\u1a5e"+ - "\u0003+\u0015\u0000\u1a5e\u1a5f\u0003%\u0012\u0000\u1a5f\u1a60\u0003\u0007"+ - "\u0003\u0000\u1a60\u1a61\u0003\u000b\u0005\u0000\u1a61\u1a62\u0003\u000f"+ - "\u0007\u0000\u1a62\u04b2\u0001\u0000\u0000\u0000\u1a63\u1a64\u0003-\u0016"+ - "\u0000\u1a64\u1a65\u0003\u000f\u0007\u0000\u1a65\u1a66\u0003\u001f\u000f"+ - "\u0000\u1a66\u1a67\u0003%\u0012\u0000\u1a67\u04b4\u0001\u0000\u0000\u0000"+ - "\u1a68\u1a69\u0003-\u0016\u0000\u1a69\u1a6a\u0003\u000f\u0007\u0000\u1a6a"+ - "\u1a6b\u0003\u001f\u000f\u0000\u1a6b\u1a6c\u0003%\u0012\u0000\u1a6c\u1a6d"+ - "\u0003\u001d\u000e\u0000\u1a6d\u1a6e\u0003\u0007\u0003\u0000\u1a6e\u1a6f"+ - "\u0003-\u0016\u0000\u1a6f\u1a70\u0003\u000f\u0007\u0000\u1a70\u04b6\u0001"+ - "\u0000\u0000\u0000\u1a71\u1a72\u0003-\u0016\u0000\u1a72\u1a73\u0003\u000f"+ - "\u0007\u0000\u1a73\u1a74\u0003\u001f\u000f\u0000\u1a74\u1a75\u0003%\u0012"+ - "\u0000\u1a75\u1a76\u0003#\u0011\u0000\u1a76\u1a77\u0003)\u0014\u0000\u1a77"+ - "\u1a78\u0003\u0007\u0003\u0000\u1a78\u1a79\u0003)\u0014\u0000\u1a79\u1a7a"+ - "\u00037\u001b\u0000\u1a7a\u04b8\u0001\u0000\u0000\u0000\u1a7b\u1a7c\u0003"+ - "-\u0016\u0000\u1a7c\u1a7d\u0003\u000f\u0007\u0000\u1a7d\u1a7e\u0003)\u0014"+ - "\u0000\u1a7e\u1a7f\u0003\u001f\u000f\u0000\u1a7f\u1a80\u0003\u0017\u000b"+ - "\u0000\u1a80\u1a81\u0003!\u0010\u0000\u1a81\u1a82\u0003\u0007\u0003\u0000"+ - "\u1a82\u1a83\u0003-\u0016\u0000\u1a83\u1a84\u0003\u000f\u0007\u0000\u1a84"+ - "\u04ba\u0001\u0000\u0000\u0000\u1a85\u1a86\u0003-\u0016\u0000\u1a86\u1a87"+ - "\u0003\u0015\n\u0000\u1a87\u1a88\u0003\u0007\u0003\u0000\u1a88\u1a89\u0003"+ - "!\u0010\u0000\u1a89\u04bc\u0001\u0000\u0000\u0000\u1a8a\u1a8b\u0003-\u0016"+ - "\u0000\u1a8b\u1a8c\u0003\u0015\n\u0000\u1a8c\u1a8d\u0003\u000f\u0007\u0000"+ - "\u1a8d\u1a8e\u0003!\u0010\u0000\u1a8e\u04be\u0001\u0000\u0000\u0000\u1a8f"+ - "\u1a90\u0003-\u0016\u0000\u1a90\u1a91\u0003\u0017\u000b\u0000\u1a91\u1a92"+ - "\u0003\u000f\u0007\u0000\u1a92\u1a93\u0003+\u0015\u0000\u1a93\u04c0\u0001"+ - "\u0000\u0000\u0000\u1a94\u1a95\u0003-\u0016\u0000\u1a95\u1a96\u0003\u0017"+ - "\u000b\u0000\u1a96\u1a97\u0003\u001f\u000f\u0000\u1a97\u1a98\u0003\u000f"+ - "\u0007\u0000\u1a98\u04c2\u0001\u0000\u0000\u0000\u1a99\u1a9a\u0003-\u0016"+ - "\u0000\u1a9a\u1a9b\u0003\u0017\u000b\u0000\u1a9b\u1a9c\u0003\u001f\u000f"+ - "\u0000\u1a9c\u1a9d\u0003\u000f\u0007\u0000\u1a9d\u1a9e\u0003+\u0015\u0000"+ - "\u1a9e\u1a9f\u0003-\u0016\u0000\u1a9f\u1aa0\u0003\u0007\u0003\u0000\u1aa0"+ - "\u1aa1\u0003\u001f\u000f\u0000\u1aa1\u1aa2\u0003%\u0012\u0000\u1aa2\u04c4"+ - "\u0001\u0000\u0000\u0000\u1aa3\u1aa4\u0003-\u0016\u0000\u1aa4\u1aa5\u0003"+ - "\u0017\u000b\u0000\u1aa5\u1aa6\u0003\u001f\u000f\u0000\u1aa6\u1aa7\u0003"+ - "\u000f\u0007\u0000\u1aa7\u1aa8\u00039\u001c\u0000\u1aa8\u1aa9\u0003#\u0011"+ - "\u0000\u1aa9\u1aaa\u0003!\u0010\u0000\u1aaa\u1aab\u0003\u000f\u0007\u0000"+ - "\u1aab\u1aac\u0005_\u0000\u0000\u1aac\u1aad\u0003\u0015\n\u0000\u1aad"+ - "\u1aae\u0003#\u0011\u0000\u1aae\u1aaf\u0003/\u0017\u0000\u1aaf\u1ab0\u0003"+ - ")\u0014\u0000\u1ab0\u04c6\u0001\u0000\u0000\u0000\u1ab1\u1ab2\u0003-\u0016"+ - "\u0000\u1ab2\u1ab3\u0003\u0017\u000b\u0000\u1ab3\u1ab4\u0003\u001f\u000f"+ - "\u0000\u1ab4\u1ab5\u0003\u000f\u0007\u0000\u1ab5\u1ab6\u00039\u001c\u0000"+ - "\u1ab6\u1ab7\u0003#\u0011\u0000\u1ab7\u1ab8\u0003!\u0010\u0000\u1ab8\u1ab9"+ - "\u0003\u000f\u0007\u0000\u1ab9\u1aba\u0005_\u0000\u0000\u1aba\u1abb\u0003"+ - "\u001f\u000f\u0000\u1abb\u1abc\u0003\u0017\u000b\u0000\u1abc\u1abd\u0003"+ - "!\u0010\u0000\u1abd\u1abe\u0003/\u0017\u0000\u1abe\u1abf\u0003-\u0016"+ - "\u0000\u1abf\u1ac0\u0003\u000f\u0007\u0000\u1ac0\u04c8\u0001\u0000\u0000"+ - "\u0000\u1ac1\u1ac2\u0003-\u0016\u0000\u1ac2\u1ac3\u0003\u0017\u000b\u0000"+ - "\u1ac3\u1ac4\u0003\u001f\u000f\u0000\u1ac4\u1ac5\u0003\u0017\u000b\u0000"+ - "\u1ac5\u1ac6\u0003!\u0010\u0000\u1ac6\u1ac7\u0003\u0013\t\u0000\u1ac7"+ - "\u04ca\u0001\u0000\u0000\u0000\u1ac8\u1ac9\u0003-\u0016\u0000\u1ac9\u1aca"+ - "\u0003#\u0011\u0000\u1aca\u04cc\u0001\u0000\u0000\u0000\u1acb\u1acc\u0003"+ - "-\u0016\u0000\u1acc\u1acd\u0003#\u0011\u0000\u1acd\u1ace\u0003\u0007\u0003"+ - "\u0000\u1ace\u1acf\u0003+\u0015\u0000\u1acf\u1ad0\u0003-\u0016\u0000\u1ad0"+ - "\u04ce\u0001\u0000\u0000\u0000\u1ad1\u1ad2\u0003-\u0016\u0000\u1ad2\u1ad3"+ - "\u0003#\u0011\u0000\u1ad3\u1ad4\u0003%\u0012\u0000\u1ad4\u04d0\u0001\u0000"+ - "\u0000\u0000\u1ad5\u1ad6\u0003-\u0016\u0000\u1ad6\u1ad7\u0003#\u0011\u0000"+ - "\u1ad7\u1ad8\u0003%\u0012\u0000\u1ad8\u1ad9\u0005_\u0000\u0000\u1ad9\u1ada"+ - "\u0003\u001d\u000e\u0000\u1ada\u1adb\u0003\u000f\u0007\u0000\u1adb\u1adc"+ - "\u00031\u0018\u0000\u1adc\u1add\u0003\u000f\u0007\u0000\u1add\u1ade\u0003"+ - "\u001d\u000e\u0000\u1ade\u1adf\u0005_\u0000\u0000\u1adf\u1ae0\u0003\u000b"+ - "\u0005\u0000\u1ae0\u1ae1\u0003#\u0011\u0000\u1ae1\u1ae2\u0003/\u0017\u0000"+ - "\u1ae2\u1ae3\u0003!\u0010\u0000\u1ae3\u1ae4\u0003-\u0016\u0000\u1ae4\u04d2"+ - "\u0001\u0000\u0000\u0000\u1ae5\u1ae6\u0003-\u0016\u0000\u1ae6\u1ae7\u0003"+ - ")\u0014\u0000\u1ae7\u1ae8\u0003\u0007\u0003\u0000\u1ae8\u1ae9\u0003\u0017"+ - "\u000b\u0000\u1ae9\u1aea\u0003\u001d\u000e\u0000\u1aea\u1aeb\u0003\u0017"+ - "\u000b\u0000\u1aeb\u1aec\u0003!\u0010\u0000\u1aec\u1aed\u0003\u0013\t"+ - "\u0000\u1aed\u04d4\u0001\u0000\u0000\u0000\u1aee\u1aef\u0003-\u0016\u0000"+ - "\u1aef\u1af0\u0003)\u0014\u0000\u1af0\u1af1\u0003\u0007\u0003\u0000\u1af1"+ - "\u1af2\u0003!\u0010\u0000\u1af2\u1af3\u0003+\u0015\u0000\u1af3\u1af4\u0003"+ - "\u0007\u0003\u0000\u1af4\u1af5\u0003\u000b\u0005\u0000\u1af5\u1af6\u0003"+ - "-\u0016\u0000\u1af6\u1af7\u0003\u0017\u000b\u0000\u1af7\u1af8\u0003#\u0011"+ - "\u0000\u1af8\u1af9\u0003!\u0010\u0000\u1af9\u04d6\u0001\u0000\u0000\u0000"+ - "\u1afa\u1afb\u0003-\u0016\u0000\u1afb\u1afc\u0003)\u0014\u0000\u1afc\u1afd"+ - "\u0003\u0007\u0003\u0000\u1afd\u1afe\u0003!\u0010\u0000\u1afe\u1aff\u0003"+ - "+\u0015\u0000\u1aff\u1b00\u0003\u0007\u0003\u0000\u1b00\u1b01\u0003\u000b"+ - "\u0005\u0000\u1b01\u1b02\u0003-\u0016\u0000\u1b02\u1b03\u0003\u0017\u000b"+ - "\u0000\u1b03\u1b04\u0003#\u0011\u0000\u1b04\u1b05\u0003!\u0010\u0000\u1b05"+ - "\u1b06\u0005_\u0000\u0000\u1b06\u1b07\u0003\u0007\u0003\u0000\u1b07\u1b08"+ - "\u0003\u000b\u0005\u0000\u1b08\u1b09\u0003-\u0016\u0000\u1b09\u1b0a\u0003"+ - "\u0017\u000b\u0000\u1b0a\u1b0b\u00031\u0018\u0000\u1b0b\u1b0c\u0003\u000f"+ - "\u0007\u0000\u1b0c\u04d8\u0001\u0000\u0000\u0000\u1b0d\u1b0e\u0003-\u0016"+ - "\u0000\u1b0e\u1b0f\u0003)\u0014\u0000\u1b0f\u1b10\u0003\u0007\u0003\u0000"+ - "\u1b10\u1b11\u0003!\u0010\u0000\u1b11\u1b12\u0003+\u0015\u0000\u1b12\u1b13"+ - "\u0003\u0007\u0003\u0000\u1b13\u1b14\u0003\u000b\u0005\u0000\u1b14\u1b15"+ - "\u0003-\u0016\u0000\u1b15\u1b16\u0003\u0017\u000b\u0000\u1b16\u1b17\u0003"+ - "#\u0011\u0000\u1b17\u1b18\u0003!\u0010\u0000\u1b18\u1b19\u0003+\u0015"+ - "\u0000\u1b19\u1b1a\u0005_\u0000\u0000\u1b1a\u1b1b\u0003\u000b\u0005\u0000"+ - "\u1b1b\u1b1c\u0003#\u0011\u0000\u1b1c\u1b1d\u0003\u001f\u000f\u0000\u1b1d"+ - "\u1b1e\u0003\u001f\u000f\u0000\u1b1e\u1b1f\u0003\u0017\u000b\u0000\u1b1f"+ - "\u1b20\u0003-\u0016\u0000\u1b20\u1b21\u0003-\u0016\u0000\u1b21\u1b22\u0003"+ - "\u000f\u0007\u0000\u1b22\u1b23\u0003\r\u0006\u0000\u1b23\u04da\u0001\u0000"+ - "\u0000\u0000\u1b24\u1b25\u0003-\u0016\u0000\u1b25\u1b26\u0003)\u0014\u0000"+ - "\u1b26\u1b27\u0003\u0007\u0003\u0000\u1b27\u1b28\u0003!\u0010\u0000\u1b28"+ - "\u1b29\u0003+\u0015\u0000\u1b29\u1b2a\u0003\u0007\u0003\u0000\u1b2a\u1b2b"+ - "\u0003\u000b\u0005\u0000\u1b2b\u1b2c\u0003-\u0016\u0000\u1b2c\u1b2d\u0003"+ - "\u0017\u000b\u0000\u1b2d\u1b2e\u0003#\u0011\u0000\u1b2e\u1b2f\u0003!\u0010"+ - "\u0000\u1b2f\u1b30\u0003+\u0015\u0000\u1b30\u1b31\u0005_\u0000\u0000\u1b31"+ - "\u1b32\u0003)\u0014\u0000\u1b32\u1b33\u0003#\u0011\u0000\u1b33\u1b34\u0003"+ - "\u001d\u000e\u0000\u1b34\u1b35\u0003\u001d\u000e\u0000\u1b35\u1b36\u0003"+ - "\u000f\u0007\u0000\u1b36\u1b37\u0003\r\u0006\u0000\u1b37\u1b38\u0005_"+ - "\u0000\u0000\u1b38\u1b39\u0003\t\u0004\u0000\u1b39\u1b3a\u0003\u0007\u0003"+ - "\u0000\u1b3a\u1b3b\u0003\u000b\u0005\u0000\u1b3b\u1b3c\u0003\u001b\r\u0000"+ - "\u1b3c\u04dc\u0001\u0000\u0000\u0000\u1b3d\u1b3e\u0003-\u0016\u0000\u1b3e"+ - "\u1b3f\u0003)\u0014\u0000\u1b3f\u1b40\u0003\u0007\u0003\u0000\u1b40\u1b41"+ - "\u0003!\u0010\u0000\u1b41\u1b42\u0003+\u0015\u0000\u1b42\u1b43\u0003\u0011"+ - "\b\u0000\u1b43\u1b44\u0003#\u0011\u0000\u1b44\u1b45\u0003)\u0014\u0000"+ - "\u1b45\u1b46\u0003\u001f\u000f\u0000\u1b46\u04de\u0001\u0000\u0000\u0000"+ - "\u1b47\u1b48\u0003-\u0016\u0000\u1b48\u1b49\u0003)\u0014\u0000\u1b49\u1b4a"+ - "\u0003\u0007\u0003\u0000\u1b4a\u1b4b\u0003!\u0010\u0000\u1b4b\u1b4c\u0003"+ - "+\u0015\u0000\u1b4c\u1b4d\u0003\u0011\b\u0000\u1b4d\u1b4e\u0003#\u0011"+ - "\u0000\u1b4e\u1b4f\u0003)\u0014\u0000\u1b4f\u1b50\u0003\u001f\u000f\u0000"+ - "\u1b50\u1b51\u0003+\u0015\u0000\u1b51\u04e0\u0001\u0000\u0000\u0000\u1b52"+ - "\u1b53\u0003-\u0016\u0000\u1b53\u1b54\u0003)\u0014\u0000\u1b54\u1b55\u0003"+ - "\u0007\u0003\u0000\u1b55\u1b56\u0003!\u0010\u0000\u1b56\u1b57\u0003+\u0015"+ - "\u0000\u1b57\u1b58\u0003\u001d\u000e\u0000\u1b58\u1b59\u0003\u0007\u0003"+ - "\u0000\u1b59\u1b5a\u0003-\u0016\u0000\u1b5a\u1b5b\u0003\u000f\u0007\u0000"+ - "\u1b5b\u04e2\u0001\u0000\u0000\u0000\u1b5c\u1b5d\u0003-\u0016\u0000\u1b5d"+ - "\u1b5e\u0003)\u0014\u0000\u1b5e\u1b5f\u0003\u0007\u0003\u0000\u1b5f\u1b60"+ - "\u0003!\u0010\u0000\u1b60\u1b61\u0003+\u0015\u0000\u1b61\u1b62\u0003\u001d"+ - "\u000e\u0000\u1b62\u1b63\u0003\u0007\u0003\u0000\u1b63\u1b64\u0003-\u0016"+ - "\u0000\u1b64\u1b65\u0003\u0017\u000b\u0000\u1b65\u1b66\u0003#\u0011\u0000"+ - "\u1b66\u1b67\u0003!\u0010\u0000\u1b67\u04e4\u0001\u0000\u0000\u0000\u1b68"+ - "\u1b69\u0003-\u0016\u0000\u1b69\u1b6a\u0003)\u0014\u0000\u1b6a\u1b6b\u0003"+ - "\u000f\u0007\u0000\u1b6b\u1b6c\u0003\u0007\u0003\u0000\u1b6c\u1b6d\u0003"+ - "-\u0016\u0000\u1b6d\u04e6\u0001\u0000\u0000\u0000\u1b6e\u1b6f\u0003-\u0016"+ - "\u0000\u1b6f\u1b70\u0003)\u0014\u0000\u1b70\u1b71\u0003\u0017\u000b\u0000"+ - "\u1b71\u1b72\u0003\u0013\t\u0000\u1b72\u1b73\u0003\u0013\t\u0000\u1b73"+ - "\u1b74\u0003\u000f\u0007\u0000\u1b74\u1b75\u0003)\u0014\u0000\u1b75\u04e8"+ - "\u0001\u0000\u0000\u0000\u1b76\u1b77\u0003-\u0016\u0000\u1b77\u1b78\u0003"+ - ")\u0014\u0000\u1b78\u1b79\u0003\u0017\u000b\u0000\u1b79\u1b7a\u0003\u0013"+ - "\t\u0000\u1b7a\u1b7b\u0003\u0013\t\u0000\u1b7b\u1b7c\u0003\u000f\u0007"+ - "\u0000\u1b7c\u1b7d\u0003)\u0014\u0000\u1b7d\u1b7e\u0005_\u0000\u0000\u1b7e"+ - "\u1b7f\u0003\u000b\u0005\u0000\u1b7f\u1b80\u0003\u0007\u0003\u0000\u1b80"+ - "\u1b81\u0003-\u0016\u0000\u1b81\u1b82\u0003\u0007\u0003\u0000\u1b82\u1b83"+ - "\u0003\u001d\u000e\u0000\u1b83\u1b84\u0003#\u0011\u0000\u1b84\u1b85\u0003"+ - "\u0013\t\u0000\u1b85\u04ea\u0001\u0000\u0000\u0000\u1b86\u1b87\u0003-"+ - "\u0016\u0000\u1b87\u1b88\u0003)\u0014\u0000\u1b88\u1b89\u0003\u0017\u000b"+ - "\u0000\u1b89\u1b8a\u0003\u0013\t\u0000\u1b8a\u1b8b\u0003\u0013\t\u0000"+ - "\u1b8b\u1b8c\u0003\u000f\u0007\u0000\u1b8c\u1b8d\u0003)\u0014\u0000\u1b8d"+ - "\u1b8e\u0005_\u0000\u0000\u1b8e\u1b8f\u0003!\u0010\u0000\u1b8f\u1b90\u0003"+ - "\u0007\u0003\u0000\u1b90\u1b91\u0003\u001f\u000f\u0000\u1b91\u1b92\u0003"+ - "\u000f\u0007\u0000\u1b92\u04ec\u0001\u0000\u0000\u0000\u1b93\u1b94\u0003"+ - "-\u0016\u0000\u1b94\u1b95\u0003)\u0014\u0000\u1b95\u1b96\u0003\u0017\u000b"+ - "\u0000\u1b96\u1b97\u0003\u0013\t\u0000\u1b97\u1b98\u0003\u0013\t\u0000"+ - "\u1b98\u1b99\u0003\u000f\u0007\u0000\u1b99\u1b9a\u0003)\u0014\u0000\u1b9a"+ - "\u1b9b\u0005_\u0000\u0000\u1b9b\u1b9c\u0003+\u0015\u0000\u1b9c\u1b9d\u0003"+ - "\u000b\u0005\u0000\u1b9d\u1b9e\u0003\u0015\n\u0000\u1b9e\u1b9f\u0003\u000f"+ - "\u0007\u0000\u1b9f\u1ba0\u0003\u001f\u000f\u0000\u1ba0\u1ba1\u0003\u0007"+ - "\u0003\u0000\u1ba1\u04ee\u0001\u0000\u0000\u0000\u1ba2\u1ba3\u0003-\u0016"+ - "\u0000\u1ba3\u1ba4\u0003)\u0014\u0000\u1ba4\u1ba5\u0003\u0017\u000b\u0000"+ - "\u1ba5\u1ba6\u0003\u001f\u000f\u0000\u1ba6\u04f0\u0001\u0000\u0000\u0000"+ - "\u1ba7\u1ba8\u0003-\u0016\u0000\u1ba8\u1ba9\u0003)\u0014\u0000\u1ba9\u1baa"+ - "\u0003/\u0017\u0000\u1baa\u1bab\u0003\u000f\u0007\u0000\u1bab\u04f2\u0001"+ - "\u0000\u0000\u0000\u1bac\u1bad\u0003-\u0016\u0000\u1bad\u1bae\u0003)\u0014"+ - "\u0000\u1bae\u1baf\u0003/\u0017\u0000\u1baf\u1bb0\u0003!\u0010\u0000\u1bb0"+ - "\u1bb1\u0003\u000b\u0005\u0000\u1bb1\u1bb2\u0003\u0007\u0003\u0000\u1bb2"+ - "\u1bb3\u0003-\u0016\u0000\u1bb3\u1bb4\u0003\u000f\u0007\u0000\u1bb4\u04f4"+ - "\u0001\u0000\u0000\u0000\u1bb5\u1bb6\u0003-\u0016\u0000\u1bb6\u1bb7\u0003"+ - ")\u0014\u0000\u1bb7\u1bb8\u0003/\u0017\u0000\u1bb8\u1bb9\u0003+\u0015"+ - "\u0000\u1bb9\u1bba\u0003-\u0016\u0000\u1bba\u1bbb\u0003\u000f\u0007\u0000"+ - "\u1bbb\u1bbc\u0003\r\u0006\u0000\u1bbc\u04f6\u0001\u0000\u0000\u0000\u1bbd"+ - "\u1bbe\u0003-\u0016\u0000\u1bbe\u1bbf\u00037\u001b\u0000\u1bbf\u1bc0\u0003"+ - "%\u0012\u0000\u1bc0\u1bc1\u0003\u000f\u0007\u0000\u1bc1\u04f8\u0001\u0000"+ - "\u0000\u0000\u1bc2\u1bc3\u0003/\u0017\u0000\u1bc3\u1bc4\u0003\u000f\u0007"+ - "\u0000\u1bc4\u1bc5\u0003+\u0015\u0000\u1bc5\u1bc6\u0003\u000b\u0005\u0000"+ - "\u1bc6\u1bc7\u0003\u0007\u0003\u0000\u1bc7\u1bc8\u0003%\u0012\u0000\u1bc8"+ - "\u1bc9\u0003\u000f\u0007\u0000\u1bc9\u04fa\u0001\u0000\u0000\u0000\u1bca"+ - "\u1bcb\u0003/\u0017\u0000\u1bcb\u1bcc\u0003!\u0010\u0000\u1bcc\u1bcd\u0003"+ - "\t\u0004\u0000\u1bcd\u1bce\u0003#\u0011\u0000\u1bce\u1bcf\u0003/\u0017"+ - "\u0000\u1bcf\u1bd0\u0003!\u0010\u0000\u1bd0\u1bd1\u0003\r\u0006\u0000"+ - "\u1bd1\u1bd2\u0003\u000f\u0007\u0000\u1bd2\u1bd3\u0003\r\u0006\u0000\u1bd3"+ - "\u04fc\u0001\u0000\u0000\u0000\u1bd4\u1bd5\u0003/\u0017\u0000\u1bd5\u1bd6"+ - "\u0003!\u0010\u0000\u1bd6\u1bd7\u0003\u000b\u0005\u0000\u1bd7\u1bd8\u0003"+ - "#\u0011\u0000\u1bd8\u1bd9\u0003\u001f\u000f\u0000\u1bd9\u1bda\u0003\u001f"+ - "\u000f\u0000\u1bda\u1bdb\u0003\u0017\u000b\u0000\u1bdb\u1bdc\u0003-\u0016"+ - "\u0000\u1bdc\u1bdd\u0003-\u0016\u0000\u1bdd\u1bde\u0003\u000f\u0007\u0000"+ - "\u1bde\u1bdf\u0003\r\u0006\u0000\u1bdf\u04fe\u0001\u0000\u0000\u0000\u1be0"+ - "\u1be1\u0003/\u0017\u0000\u1be1\u1be2\u0003!\u0010\u0000\u1be2\u1be3\u0003"+ - "\r\u0006\u0000\u1be3\u1be4\u0003\u000f\u0007\u0000\u1be4\u1be5\u0003)"+ - "\u0014\u0000\u1be5\u0500\u0001\u0000\u0000\u0000\u1be6\u1be7\u0003/\u0017"+ - "\u0000\u1be7\u1be8\u0003!\u0010\u0000\u1be8\u1be9\u0003\u000f\u0007\u0000"+ - "\u1be9\u1bea\u0003!\u0010\u0000\u1bea\u1beb\u0003\u000b\u0005\u0000\u1beb"+ - "\u1bec\u0003)\u0014\u0000\u1bec\u1bed\u00037\u001b\u0000\u1bed\u1bee\u0003"+ - "%\u0012\u0000\u1bee\u1bef\u0003-\u0016\u0000\u1bef\u1bf0\u0003\u000f\u0007"+ - "\u0000\u1bf0\u1bf1\u0003\r\u0006\u0000\u1bf1\u0502\u0001\u0000\u0000\u0000"+ - "\u1bf2\u1bf3\u0003/\u0017\u0000\u1bf3\u1bf4\u0003!\u0010\u0000\u1bf4\u1bf5"+ - "\u0003\u0017\u000b\u0000\u1bf5\u1bf6\u0003#\u0011\u0000\u1bf6\u1bf7\u0003"+ - "!\u0010\u0000\u1bf7\u0504\u0001\u0000\u0000\u0000\u1bf8\u1bf9\u0003/\u0017"+ - "\u0000\u1bf9\u1bfa\u0003!\u0010\u0000\u1bfa\u1bfb\u0003\u0017\u000b\u0000"+ - "\u1bfb\u1bfc\u0003\'\u0013\u0000\u1bfc\u1bfd\u0003/\u0017\u0000\u1bfd"+ - "\u1bfe\u0003\u000f\u0007\u0000\u1bfe\u0506\u0001\u0000\u0000\u0000\u1bff"+ - "\u1c00\u0003/\u0017\u0000\u1c00\u1c01\u0003!\u0010\u0000\u1c01\u1c02\u0003"+ - "\u001b\r\u0000\u1c02\u1c03\u0003!\u0010\u0000\u1c03\u1c04\u0003#\u0011"+ - "\u0000\u1c04\u1c05\u00033\u0019\u0000\u1c05\u1c06\u0003!\u0010\u0000\u1c06"+ - "\u0508\u0001\u0000\u0000\u0000\u1c07\u1c08\u0003/\u0017\u0000\u1c08\u1c09"+ - "\u0003!\u0010\u0000\u1c09\u1c0a\u0003\u001d\u000e\u0000\u1c0a\u1c0b\u0003"+ - "\u0017\u000b\u0000\u1c0b\u1c0c\u0003+\u0015\u0000\u1c0c\u1c0d\u0003-\u0016"+ - "\u0000\u1c0d\u1c0e\u0003\u000f\u0007\u0000\u1c0e\u1c0f\u0003!\u0010\u0000"+ - "\u1c0f\u050a\u0001\u0000\u0000\u0000\u1c10\u1c11\u0003/\u0017\u0000\u1c11"+ - "\u1c12\u0003!\u0010\u0000\u1c12\u1c13\u0003\u001d\u000e\u0000\u1c13\u1c14"+ - "\u0003#\u0011\u0000\u1c14\u1c15\u0003\u0013\t\u0000\u1c15\u1c16\u0003"+ - "\u0013\t\u0000\u1c16\u1c17\u0003\u000f\u0007\u0000\u1c17\u1c18\u0003\r"+ - "\u0006\u0000\u1c18\u050c\u0001\u0000\u0000\u0000\u1c19\u1c1a\u0003/\u0017"+ - "\u0000\u1c1a\u1c1b\u0003!\u0010\u0000\u1c1b\u1c1c\u0003!\u0010\u0000\u1c1c"+ - "\u1c1d\u0003\u0007\u0003\u0000\u1c1d\u1c1e\u0003\u001f\u000f\u0000\u1c1e"+ - "\u1c1f\u0003\u000f\u0007\u0000\u1c1f\u1c20\u0003\r\u0006\u0000\u1c20\u050e"+ - "\u0001\u0000\u0000\u0000\u1c21\u1c22\u0003/\u0017\u0000\u1c22\u1c23\u0003"+ - "!\u0010\u0000\u1c23\u1c24\u0003!\u0010\u0000\u1c24\u1c25\u0003\u000f\u0007"+ - "\u0000\u1c25\u1c26\u0003+\u0015\u0000\u1c26\u1c27\u0003-\u0016\u0000\u1c27"+ - "\u0510\u0001\u0000\u0000\u0000\u1c28\u1c29\u0003/\u0017\u0000\u1c29\u1c2a"+ - "\u0003!\u0010\u0000\u1c2a\u1c2b\u0003-\u0016\u0000\u1c2b\u1c2c\u0003\u0017"+ - "\u000b\u0000\u1c2c\u1c2d\u0003\u001d\u000e\u0000\u1c2d\u0512\u0001\u0000"+ - "\u0000\u0000\u1c2e\u1c2f\u0003/\u0017\u0000\u1c2f\u1c30\u0003%\u0012\u0000"+ - "\u1c30\u1c31\u0003\r\u0006\u0000\u1c31\u1c32\u0003\u0007\u0003\u0000\u1c32"+ - "\u1c33\u0003-\u0016\u0000\u1c33\u1c34\u0003\u000f\u0007\u0000\u1c34\u0514"+ - "\u0001\u0000\u0000\u0000\u1c35\u1c36\u0003/\u0017\u0000\u1c36\u1c37\u0003"+ - "%\u0012\u0000\u1c37\u1c38\u0003%\u0012\u0000\u1c38\u1c39\u0003\u000f\u0007"+ - "\u0000\u1c39\u1c3a\u0003)\u0014\u0000\u1c3a\u0516\u0001\u0000\u0000\u0000"+ - "\u1c3b\u1c3c\u0003/\u0017\u0000\u1c3c\u1c3d\u0003+\u0015\u0000\u1c3d\u1c3e"+ - "\u0003\u0007\u0003\u0000\u1c3e\u1c3f\u0003\u0013\t\u0000\u1c3f\u1c40\u0003"+ - "\u000f\u0007\u0000\u1c40\u0518\u0001\u0000\u0000\u0000\u1c41\u1c42\u0003"+ - "/\u0017\u0000\u1c42\u1c43\u0003+\u0015\u0000\u1c43\u1c44\u0003\u000f\u0007"+ - "\u0000\u1c44\u1c45\u0003)\u0014\u0000\u1c45\u051a\u0001\u0000\u0000\u0000"+ - "\u1c46\u1c47\u0003/\u0017\u0000\u1c47\u1c48\u0003+\u0015\u0000\u1c48\u1c49"+ - "\u0003\u000f\u0007\u0000\u1c49\u1c4a\u0003)\u0014\u0000\u1c4a\u1c4b\u0005"+ - "_\u0000\u0000\u1c4b\u1c4c\u0003\r\u0006\u0000\u1c4c\u1c4d\u0003\u000f"+ - "\u0007\u0000\u1c4d\u1c4e\u0003\u0011\b\u0000\u1c4e\u1c4f\u0003\u0017\u000b"+ - "\u0000\u1c4f\u1c50\u0003!\u0010\u0000\u1c50\u1c51\u0003\u000f\u0007\u0000"+ - "\u1c51\u1c52\u0003\r\u0006\u0000\u1c52\u1c53\u0005_\u0000\u0000\u1c53"+ - "\u1c54\u0003-\u0016\u0000\u1c54\u1c55\u00037\u001b\u0000\u1c55\u1c56\u0003"+ - "%\u0012\u0000\u1c56\u1c57\u0003\u000f\u0007\u0000\u1c57\u1c58\u0005_\u0000"+ - "\u0000\u1c58\u1c59\u0003\u000b\u0005\u0000\u1c59\u1c5a\u0003\u0007\u0003"+ - "\u0000\u1c5a\u1c5b\u0003-\u0016\u0000\u1c5b\u1c5c\u0003\u0007\u0003\u0000"+ - "\u1c5c\u1c5d\u0003\u001d\u000e\u0000\u1c5d\u1c5e\u0003#\u0011\u0000\u1c5e"+ - "\u1c5f\u0003\u0013\t\u0000\u1c5f\u051c\u0001\u0000\u0000\u0000\u1c60\u1c61"+ - "\u0003/\u0017\u0000\u1c61\u1c62\u0003+\u0015\u0000\u1c62\u1c63\u0003\u000f"+ - "\u0007\u0000\u1c63\u1c64\u0003)\u0014\u0000\u1c64\u1c65\u0005_\u0000\u0000"+ - "\u1c65\u1c66\u0003\r\u0006\u0000\u1c66\u1c67\u0003\u000f\u0007\u0000\u1c67"+ - "\u1c68\u0003\u0011\b\u0000\u1c68\u1c69\u0003\u0017\u000b\u0000\u1c69\u1c6a"+ - "\u0003!\u0010\u0000\u1c6a\u1c6b\u0003\u000f\u0007\u0000\u1c6b\u1c6c\u0003"+ - "\r\u0006\u0000\u1c6c\u1c6d\u0005_\u0000\u0000\u1c6d\u1c6e\u0003-\u0016"+ - "\u0000\u1c6e\u1c6f\u00037\u001b\u0000\u1c6f\u1c70\u0003%\u0012\u0000\u1c70"+ - "\u1c71\u0003\u000f\u0007\u0000\u1c71\u1c72\u0005_\u0000\u0000\u1c72\u1c73"+ - "\u0003\u000b\u0005\u0000\u1c73\u1c74\u0003#\u0011\u0000\u1c74\u1c75\u0003"+ - "\r\u0006\u0000\u1c75\u1c76\u0003\u000f\u0007\u0000\u1c76\u051e\u0001\u0000"+ - "\u0000\u0000\u1c77\u1c78\u0003/\u0017\u0000\u1c78\u1c79\u0003+\u0015\u0000"+ - "\u1c79\u1c7a\u0003\u000f\u0007\u0000\u1c7a\u1c7b\u0003)\u0014\u0000\u1c7b"+ - "\u1c7c\u0005_\u0000\u0000\u1c7c\u1c7d\u0003\r\u0006\u0000\u1c7d\u1c7e"+ - "\u0003\u000f\u0007\u0000\u1c7e\u1c7f\u0003\u0011\b\u0000\u1c7f\u1c80\u0003"+ - "\u0017\u000b\u0000\u1c80\u1c81\u0003!\u0010\u0000\u1c81\u1c82\u0003\u000f"+ - "\u0007\u0000\u1c82\u1c83\u0003\r\u0006\u0000\u1c83\u1c84\u0005_\u0000"+ - "\u0000\u1c84\u1c85\u0003-\u0016\u0000\u1c85\u1c86\u00037\u001b\u0000\u1c86"+ - "\u1c87\u0003%\u0012\u0000\u1c87\u1c88\u0003\u000f\u0007\u0000\u1c88\u1c89"+ - "\u0005_\u0000\u0000\u1c89\u1c8a\u0003!\u0010\u0000\u1c8a\u1c8b\u0003\u0007"+ - "\u0003\u0000\u1c8b\u1c8c\u0003\u001f\u000f\u0000\u1c8c\u1c8d\u0003\u000f"+ - "\u0007\u0000\u1c8d\u0520\u0001\u0000\u0000\u0000\u1c8e\u1c8f\u0003/\u0017"+ - "\u0000\u1c8f\u1c90\u0003+\u0015\u0000\u1c90\u1c91\u0003\u000f\u0007\u0000"+ - "\u1c91\u1c92\u0003)\u0014\u0000\u1c92\u1c93\u0005_\u0000\u0000\u1c93\u1c94"+ - "\u0003\r\u0006\u0000\u1c94\u1c95\u0003\u000f\u0007\u0000\u1c95\u1c96\u0003"+ - "\u0011\b\u0000\u1c96\u1c97\u0003\u0017\u000b\u0000\u1c97\u1c98\u0003!"+ - "\u0010\u0000\u1c98\u1c99\u0003\u000f\u0007\u0000\u1c99\u1c9a\u0003\r\u0006"+ - "\u0000\u1c9a\u1c9b\u0005_\u0000\u0000\u1c9b\u1c9c\u0003-\u0016\u0000\u1c9c"+ - "\u1c9d\u00037\u001b\u0000\u1c9d\u1c9e\u0003%\u0012\u0000\u1c9e\u1c9f\u0003"+ - "\u000f\u0007\u0000\u1c9f\u1ca0\u0005_\u0000\u0000\u1ca0\u1ca1\u0003+\u0015"+ - "\u0000\u1ca1\u1ca2\u0003\u000b\u0005\u0000\u1ca2\u1ca3\u0003\u0015\n\u0000"+ - "\u1ca3\u1ca4\u0003\u000f\u0007\u0000\u1ca4\u1ca5\u0003\u001f\u000f\u0000"+ - "\u1ca5\u1ca6\u0003\u0007\u0003\u0000\u1ca6\u0522\u0001\u0000\u0000\u0000"+ - "\u1ca7\u1ca8\u0003/\u0017\u0000\u1ca8\u1ca9\u0003+\u0015\u0000\u1ca9\u1caa"+ - "\u0003\u0017\u000b\u0000\u1caa\u1cab\u0003!\u0010\u0000\u1cab\u1cac\u0003"+ - "\u0013\t\u0000\u1cac\u0524\u0001\u0000\u0000\u0000\u1cad\u1cae\u00031"+ - "\u0018\u0000\u1cae\u1caf\u0003\u0007\u0003\u0000\u1caf\u1cb0\u0003\u000b"+ - "\u0005\u0000\u1cb0\u1cb1\u0003/\u0017\u0000\u1cb1\u1cb2\u0003/\u0017\u0000"+ - "\u1cb2\u1cb3\u0003\u001f\u000f\u0000\u1cb3\u0526\u0001\u0000\u0000\u0000"+ - "\u1cb4\u1cb5\u00031\u0018\u0000\u1cb5\u1cb6\u0003\u0007\u0003\u0000\u1cb6"+ - "\u1cb7\u0003\u001d\u000e\u0000\u1cb7\u1cb8\u0003\u0017\u000b\u0000\u1cb8"+ - "\u1cb9\u0003\r\u0006\u0000\u1cb9\u0528\u0001\u0000\u0000\u0000\u1cba\u1cbb"+ - "\u00031\u0018\u0000\u1cbb\u1cbc\u0003\u0007\u0003\u0000\u1cbc\u1cbd\u0003"+ - "\u001d\u000e\u0000\u1cbd\u1cbe\u0003\u0017\u000b\u0000\u1cbe\u1cbf\u0003"+ - "\r\u0006\u0000\u1cbf\u1cc0\u0003\u0007\u0003\u0000\u1cc0\u1cc1\u0003-"+ - "\u0016\u0000\u1cc1\u1cc2\u0003\u000f\u0007\u0000\u1cc2\u052a\u0001\u0000"+ - "\u0000\u0000\u1cc3\u1cc4\u00031\u0018\u0000\u1cc4\u1cc5\u0003\u0007\u0003"+ - "\u0000\u1cc5\u1cc6\u0003\u001d\u000e\u0000\u1cc6\u1cc7\u0003\u0017\u000b"+ - "\u0000\u1cc7\u1cc8\u0003\r\u0006\u0000\u1cc8\u1cc9\u0003\u0007\u0003\u0000"+ - "\u1cc9\u1cca\u0003-\u0016\u0000\u1cca\u1ccb\u0003#\u0011\u0000\u1ccb\u1ccc"+ - "\u0003)\u0014\u0000\u1ccc\u052c\u0001\u0000\u0000\u0000\u1ccd\u1cce\u0003"+ - "1\u0018\u0000\u1cce\u1ccf\u0003\u0007\u0003\u0000\u1ccf\u1cd0\u0003\u001d"+ - "\u000e\u0000\u1cd0\u1cd1\u0003/\u0017\u0000\u1cd1\u1cd2\u0003\u000f\u0007"+ - "\u0000\u1cd2\u052e\u0001\u0000\u0000\u0000\u1cd3\u1cd4\u00031\u0018\u0000"+ - "\u1cd4\u1cd5\u0003\u0007\u0003\u0000\u1cd5\u1cd6\u0003\u001d\u000e\u0000"+ - "\u1cd6\u1cd7\u0003/\u0017\u0000\u1cd7\u1cd8\u0003\u000f\u0007\u0000\u1cd8"+ - "\u1cd9\u0003+\u0015\u0000\u1cd9\u0530\u0001\u0000\u0000\u0000\u1cda\u1cdb"+ - "\u00031\u0018\u0000\u1cdb\u1cdc\u0003\u0007\u0003\u0000\u1cdc\u1cdd\u0003"+ - ")\u0014\u0000\u1cdd\u1cde\u0005_\u0000\u0000\u1cde\u1cdf\u0003%\u0012"+ - "\u0000\u1cdf\u1ce0\u0003#\u0011\u0000\u1ce0\u1ce1\u0003%\u0012\u0000\u1ce1"+ - "\u0532\u0001\u0000\u0000\u0000\u1ce2\u1ce3\u00031\u0018\u0000\u1ce3\u1ce4"+ - "\u0003\u0007\u0003\u0000\u1ce4\u1ce5\u0003)\u0014\u0000\u1ce5\u1ce6\u0005"+ - "_\u0000\u0000\u1ce6\u1ce7\u0003+\u0015\u0000\u1ce7\u1ce8\u0003\u0007\u0003"+ - "\u0000\u1ce8\u1ce9\u0003\u001f\u000f\u0000\u1ce9\u1cea\u0003%\u0012\u0000"+ - "\u1cea\u0534\u0001\u0000\u0000\u0000\u1ceb\u1cec\u00031\u0018\u0000\u1cec"+ - "\u1ced\u0003\u0007\u0003\u0000\u1ced\u1cee\u0003)\u0014\u0000\u1cee\u1cef"+ - "\u0003\u000b\u0005\u0000\u1cef\u1cf0\u0003\u0015\n\u0000\u1cf0\u1cf1\u0003"+ - "\u0007\u0003\u0000\u1cf1\u1cf2\u0003)\u0014\u0000\u1cf2\u0536\u0001\u0000"+ - "\u0000\u0000\u1cf3\u1cf4\u00031\u0018\u0000\u1cf4\u1cf5\u0003\u0007\u0003"+ - "\u0000\u1cf5\u1cf6\u0003)\u0014\u0000\u1cf6\u1cf7\u0003\u0017\u000b\u0000"+ - "\u1cf7\u1cf8\u0003\u0007\u0003\u0000\u1cf8\u1cf9\u0003\t\u0004\u0000\u1cf9"+ - "\u1cfa\u0003\u001d\u000e\u0000\u1cfa\u1cfb\u0003\u000f\u0007\u0000\u1cfb"+ - "\u0538\u0001\u0000\u0000\u0000\u1cfc\u1cfd\u00031\u0018\u0000\u1cfd\u1cfe"+ - "\u0003\u0007\u0003\u0000\u1cfe\u1cff\u0003)\u0014\u0000\u1cff\u1d00\u0003"+ - "\u0017\u000b\u0000\u1d00\u1d01\u0003\u0007\u0003\u0000\u1d01\u1d02\u0003"+ - "\r\u0006\u0000\u1d02\u1d03\u0003\u0017\u000b\u0000\u1d03\u1d04\u0003\u000b"+ - "\u0005\u0000\u1d04\u053a\u0001\u0000\u0000\u0000\u1d05\u1d06\u00031\u0018"+ - "\u0000\u1d06\u1d07\u0003\u0007\u0003\u0000\u1d07\u1d08\u0003)\u0014\u0000"+ - "\u1d08\u1d09\u00037\u001b\u0000\u1d09\u1d0a\u0003\u0017\u000b\u0000\u1d0a"+ - "\u1d0b\u0003!\u0010\u0000\u1d0b\u1d0c\u0003\u0013\t\u0000\u1d0c\u053c"+ - "\u0001\u0000\u0000\u0000\u1d0d\u1d0e\u00031\u0018\u0000\u1d0e\u1d0f\u0003"+ - "\u000f\u0007\u0000\u1d0f\u1d10\u0003)\u0014\u0000\u1d10\u1d11\u0003\t"+ - "\u0004\u0000\u1d11\u1d12\u0003#\u0011\u0000\u1d12\u1d13\u0003+\u0015\u0000"+ - "\u1d13\u1d14\u0003\u000f\u0007\u0000\u1d14\u053e\u0001\u0000\u0000\u0000"+ - "\u1d15\u1d16\u00031\u0018\u0000\u1d16\u1d17\u0003\u0017\u000b\u0000\u1d17"+ - "\u1d18\u0003\u000f\u0007\u0000\u1d18\u1d19\u00033\u0019\u0000\u1d19\u0540"+ - "\u0001\u0000\u0000\u0000\u1d1a\u1d1b\u00031\u0018\u0000\u1d1b\u1d1c\u0003"+ - "#\u0011\u0000\u1d1c\u1d1d\u0003\u001d\u000e\u0000\u1d1d\u1d1e\u0003\u0007"+ - "\u0003\u0000\u1d1e\u1d1f\u0003-\u0016\u0000\u1d1f\u1d20\u0003\u0017\u000b"+ - "\u0000\u1d20\u1d21\u0003\u001d\u000e\u0000\u1d21\u1d22\u0003\u000f\u0007"+ - "\u0000\u1d22\u0542\u0001\u0000\u0000\u0000\u1d23\u1d24\u00033\u0019\u0000"+ - "\u1d24\u1d25\u0003\u0015\n\u0000\u1d25\u1d26\u0003\u000f\u0007\u0000\u1d26"+ - "\u1d27\u0003!\u0010\u0000\u1d27\u0544\u0001\u0000\u0000\u0000\u1d28\u1d29"+ - "\u00033\u0019\u0000\u1d29\u1d2a\u0003\u0015\n\u0000\u1d2a\u1d2b\u0003"+ - "\u000f\u0007\u0000\u1d2b\u1d2c\u0003!\u0010\u0000\u1d2c\u1d2d\u0003\u000f"+ - "\u0007\u0000\u1d2d\u1d2e\u00031\u0018\u0000\u1d2e\u1d2f\u0003\u000f\u0007"+ - "\u0000\u1d2f\u1d30\u0003)\u0014\u0000\u1d30\u0546\u0001\u0000\u0000\u0000"+ - "\u1d31\u1d32\u00033\u0019\u0000\u1d32\u1d33\u0003\u0015\n\u0000\u1d33"+ - "\u1d34\u0003\u000f\u0007\u0000\u1d34\u1d35\u0003)\u0014\u0000\u1d35\u1d36"+ - "\u0003\u000f\u0007\u0000\u1d36\u0548\u0001\u0000\u0000\u0000\u1d37\u1d38"+ - "\u00033\u0019\u0000\u1d38\u1d39\u0003\u0017\u000b\u0000\u1d39\u1d3a\u0003"+ - "\r\u0006\u0000\u1d3a\u1d3b\u0003-\u0016\u0000\u1d3b\u1d3c\u0003\u0015"+ - "\n\u0000\u1d3c\u1d3d\u0005_\u0000\u0000\u1d3d\u1d3e\u0003\t\u0004\u0000"+ - "\u1d3e\u1d3f\u0003/\u0017\u0000\u1d3f\u1d40\u0003\u000b\u0005\u0000\u1d40"+ - "\u1d41\u0003\u001b\r\u0000\u1d41\u1d42\u0003\u000f\u0007\u0000\u1d42\u1d43"+ - "\u0003-\u0016\u0000\u1d43\u054a\u0001\u0000\u0000\u0000\u1d44\u1d45\u0003"+ - "3\u0019\u0000\u1d45\u1d46\u0003\u0017\u000b\u0000\u1d46\u1d47\u0003!\u0010"+ - "\u0000\u1d47\u1d48\u0003\r\u0006\u0000\u1d48\u1d49\u0003#\u0011\u0000"+ - "\u1d49\u1d4a\u00033\u0019\u0000\u1d4a\u054c\u0001\u0000\u0000\u0000\u1d4b"+ - "\u1d4c\u00033\u0019\u0000\u1d4c\u1d4d\u0003\u0017\u000b\u0000\u1d4d\u1d4e"+ - "\u0003-\u0016\u0000\u1d4e\u1d4f\u0003\u0015\n\u0000\u1d4f\u054e\u0001"+ - "\u0000\u0000\u0000\u1d50\u1d51\u00033\u0019\u0000\u1d51\u1d52\u0003\u0017"+ - "\u000b\u0000\u1d52\u1d53\u0003-\u0016\u0000\u1d53\u1d54\u0003\u0015\n"+ - "\u0000\u1d54\u1d55\u0003\u0017\u000b\u0000\u1d55\u1d56\u0003!\u0010\u0000"+ - "\u1d56\u0550\u0001\u0000\u0000\u0000\u1d57\u1d58\u00033\u0019\u0000\u1d58"+ - "\u1d59\u0003\u0017\u000b\u0000\u1d59\u1d5a\u0003-\u0016\u0000\u1d5a\u1d5b"+ - "\u0003\u0015\n\u0000\u1d5b\u1d5c\u0003#\u0011\u0000\u1d5c\u1d5d\u0003"+ - "/\u0017\u0000\u1d5d\u1d5e\u0003-\u0016\u0000\u1d5e\u0552\u0001\u0000\u0000"+ - "\u0000\u1d5f\u1d60\u00033\u0019\u0000\u1d60\u1d61\u0003#\u0011\u0000\u1d61"+ - "\u1d62\u0003)\u0014\u0000\u1d62\u1d63\u0003\u001b\r\u0000\u1d63\u0554"+ - "\u0001\u0000\u0000\u0000\u1d64\u1d65\u00033\u0019\u0000\u1d65\u1d66\u0003"+ - ")\u0014\u0000\u1d66\u1d67\u0003\u0017\u000b\u0000\u1d67\u1d68\u0003-\u0016"+ - "\u0000\u1d68\u1d69\u0003\u000f\u0007\u0000\u1d69\u0556\u0001\u0000\u0000"+ - "\u0000\u1d6a\u1d6b\u00037\u001b\u0000\u1d6b\u1d6c\u0003\u0007\u0003\u0000"+ - "\u1d6c\u1d6d\u0003\u001f\u000f\u0000\u1d6d\u1d6e\u0003\u001d\u000e\u0000"+ - "\u1d6e\u0558\u0001\u0000\u0000\u0000\u1d6f\u1d70\u00037\u001b\u0000\u1d70"+ - "\u1d71\u0003\u000f\u0007\u0000\u1d71\u1d72\u0003\u0007\u0003\u0000\u1d72"+ - "\u1d73\u0003)\u0014\u0000\u1d73\u055a\u0001\u0000\u0000\u0000\u1d74\u1d75"+ - "\u00037\u001b\u0000\u1d75\u1d76\u0003\u000f\u0007\u0000\u1d76\u1d77\u0003"+ - "+\u0015\u0000\u1d77\u055c\u0001\u0000\u0000\u0000\u1d78\u1d79\u00039\u001c"+ - "\u0000\u1d79\u1d7a\u0003#\u0011\u0000\u1d7a\u1d7b\u0003!\u0010\u0000\u1d7b"+ - "\u1d7c\u0003\u000f\u0007\u0000\u1d7c\u055e\u0001\u0000\u0000\u0000\u1d7d"+ - "\u1d7e\u0003+\u0015\u0000\u1d7e\u1d7f\u0003/\u0017\u0000\u1d7f\u1d80\u0003"+ - "%\u0012\u0000\u1d80\u1d81\u0003\u000f\u0007\u0000\u1d81\u1d82\u0003)\u0014"+ - "\u0000\u1d82\u1d83\u0003/\u0017\u0000\u1d83\u1d84\u0003+\u0015\u0000\u1d84"+ - "\u1d85\u0003\u000f\u0007\u0000\u1d85\u1d86\u0003)\u0014\u0000\u1d86\u0560"+ - "\u0001\u0000\u0000\u0000\u1d87\u1d88\u0003!\u0010\u0000\u1d88\u1d89\u0003"+ - "#\u0011\u0000\u1d89\u1d8a\u0003+\u0015\u0000\u1d8a\u1d8b\u0003/\u0017"+ - "\u0000\u1d8b\u1d8c\u0003%\u0012\u0000\u1d8c\u1d8d\u0003\u000f\u0007\u0000"+ - "\u1d8d\u1d8e\u0003)\u0014\u0000\u1d8e\u1d8f\u0003/\u0017\u0000\u1d8f\u1d90"+ - "\u0003+\u0015\u0000\u1d90\u1d91\u0003\u000f\u0007\u0000\u1d91\u1d92\u0003"+ - ")\u0014\u0000\u1d92\u0562\u0001\u0000\u0000\u0000\u1d93\u1d94\u0003\u000b"+ - "\u0005\u0000\u1d94\u1d95\u0003)\u0014\u0000\u1d95\u1d96\u0003\u000f\u0007"+ - "\u0000\u1d96\u1d97\u0003\u0007\u0003\u0000\u1d97\u1d98\u0003-\u0016\u0000"+ - "\u1d98\u1d99\u0003\u000f\u0007\u0000\u1d99\u1d9a\u0003)\u0014\u0000\u1d9a"+ - "\u1d9b\u0003#\u0011\u0000\u1d9b\u1d9c\u0003\u001d\u000e\u0000\u1d9c\u1d9d"+ - "\u0003\u000f\u0007\u0000\u1d9d\u0564\u0001\u0000\u0000\u0000\u1d9e\u1d9f"+ - "\u0003!\u0010\u0000\u1d9f\u1da0\u0003#\u0011\u0000\u1da0\u1da1\u0003\u000b"+ - "\u0005\u0000\u1da1\u1da2\u0003)\u0014\u0000\u1da2\u1da3\u0003\u000f\u0007"+ - "\u0000\u1da3\u1da4\u0003\u0007\u0003\u0000\u1da4\u1da5\u0003-\u0016\u0000"+ - "\u1da5\u1da6\u0003\u000f\u0007\u0000\u1da6\u1da7\u0003)\u0014\u0000\u1da7"+ - "\u1da8\u0003#\u0011\u0000\u1da8\u1da9\u0003\u001d\u000e\u0000\u1da9\u1daa"+ - "\u0003\u000f\u0007\u0000\u1daa\u0566\u0001\u0000\u0000\u0000\u1dab\u1dac"+ - "\u0003\u0017\u000b\u0000\u1dac\u1dad\u0003!\u0010\u0000\u1dad\u1dae\u0003"+ - "\u0015\n\u0000\u1dae\u1daf\u0003\u000f\u0007\u0000\u1daf\u1db0\u0003)"+ - "\u0014\u0000\u1db0\u1db1\u0003\u0017\u000b\u0000\u1db1\u1db2\u0003-\u0016"+ - "\u0000\u1db2\u0568\u0001\u0000\u0000\u0000\u1db3\u1db4\u0003!\u0010\u0000"+ - "\u1db4\u1db5\u0003#\u0011\u0000\u1db5\u1db6\u0003\u0017\u000b\u0000\u1db6"+ - "\u1db7\u0003!\u0010\u0000\u1db7\u1db8\u0003\u0015\n\u0000\u1db8\u1db9"+ - "\u0003\u000f\u0007\u0000\u1db9\u1dba\u0003)\u0014\u0000\u1dba\u1dbb\u0003"+ - "\u0017\u000b\u0000\u1dbb\u1dbc\u0003-\u0016\u0000\u1dbc\u056a\u0001\u0000"+ - "\u0000\u0000\u1dbd\u1dbe\u0003\u001d\u000e\u0000\u1dbe\u1dbf\u0003#\u0011"+ - "\u0000\u1dbf\u1dc0\u0003\u0013\t\u0000\u1dc0\u1dc1\u0003\u0017\u000b\u0000"+ - "\u1dc1\u1dc2\u0003!\u0010\u0000\u1dc2\u056c\u0001\u0000\u0000\u0000\u1dc3"+ - "\u1dc4\u0003!\u0010\u0000\u1dc4\u1dc5\u0003#\u0011\u0000\u1dc5\u1dc6\u0003"+ - "\u001d\u000e\u0000\u1dc6\u1dc7\u0003#\u0011\u0000\u1dc7\u1dc8\u0003\u0013"+ - "\t\u0000\u1dc8\u1dc9\u0003\u0017\u000b\u0000\u1dc9\u1dca\u0003!\u0010"+ - "\u0000\u1dca\u056e\u0001\u0000\u0000\u0000\u1dcb\u1dcc\u0003)\u0014\u0000"+ - "\u1dcc\u1dcd\u0003\u000f\u0007\u0000\u1dcd\u1dce\u0003%\u0012\u0000\u1dce"+ - "\u1dcf\u0003\u001d\u000e\u0000\u1dcf\u1dd0\u0003\u0017\u000b\u0000\u1dd0"+ - "\u1dd1\u0003\u000b\u0005\u0000\u1dd1\u1dd2\u0003\u0007\u0003\u0000\u1dd2"+ - "\u1dd3\u0003-\u0016\u0000\u1dd3\u1dd4\u0003\u0017\u000b\u0000\u1dd4\u1dd5"+ - "\u0003#\u0011\u0000\u1dd5\u1dd6\u0003!\u0010\u0000\u1dd6\u0570\u0001\u0000"+ - "\u0000\u0000\u1dd7\u1dd8\u0003!\u0010\u0000\u1dd8\u1dd9\u0003#\u0011\u0000"+ - "\u1dd9\u1dda\u0003)\u0014\u0000\u1dda\u1ddb\u0003\u000f\u0007\u0000\u1ddb"+ - "\u1ddc\u0003%\u0012\u0000\u1ddc\u1ddd\u0003\u001d\u000e\u0000\u1ddd\u1dde"+ - "\u0003\u0017\u000b\u0000\u1dde\u1ddf\u0003\u000b\u0005\u0000\u1ddf\u1de0"+ - "\u0003\u0007\u0003\u0000\u1de0\u1de1\u0003-\u0016\u0000\u1de1\u1de2\u0003"+ - "\u0017\u000b\u0000\u1de2\u1de3\u0003#\u0011\u0000\u1de3\u1de4\u0003!\u0010"+ - "\u0000\u1de4\u0572\u0001\u0000\u0000\u0000\u1de5\u1de6\u0003\t\u0004\u0000"+ - "\u1de6\u1de7\u00037\u001b\u0000\u1de7\u1de8\u0003%\u0012\u0000\u1de8\u1de9"+ - "\u0003\u0007\u0003\u0000\u1de9\u1dea\u0003+\u0015\u0000\u1dea\u1deb\u0003"+ - "+\u0015\u0000\u1deb\u1dec\u0003)\u0014\u0000\u1dec\u1ded\u0003\u001d\u000e"+ - "\u0000\u1ded\u1dee\u0003+\u0015\u0000\u1dee\u0574\u0001\u0000\u0000\u0000"+ - "\u1def\u1df0\u0003!\u0010\u0000\u1df0\u1df1\u0003#\u0011\u0000\u1df1\u1df2"+ - "\u0003\t\u0004\u0000\u1df2\u1df3\u00037\u001b\u0000\u1df3\u1df4\u0003"+ - "%\u0012\u0000\u1df4\u1df5\u0003\u0007\u0003\u0000\u1df5\u1df6\u0003+\u0015"+ - "\u0000\u1df6\u1df7\u0003+\u0015\u0000\u1df7\u1df8\u0003)\u0014\u0000\u1df8"+ - "\u1df9\u0003\u001d\u000e\u0000\u1df9\u1dfa\u0003+\u0015\u0000\u1dfa\u0576"+ - "\u0001\u0000\u0000\u0000\u1dfb\u1dfc\u0003+\u0015\u0000\u1dfc\u1dfd\u0003"+ - "\u0011\b\u0000\u1dfd\u1dfe\u0003/\u0017\u0000\u1dfe\u1dff\u0003!\u0010"+ - "\u0000\u1dff\u1e00\u0003\u000b\u0005\u0000\u1e00\u0578\u0001\u0000\u0000"+ - "\u0000\u1e01\u1e02\u0003+\u0015\u0000\u1e02\u1e03\u0003-\u0016\u0000\u1e03"+ - "\u1e04\u00037\u001b\u0000\u1e04\u1e05\u0003%\u0012\u0000\u1e05\u1e06\u0003"+ - "\u000f\u0007\u0000\u1e06\u057a\u0001\u0000\u0000\u0000\u1e07\u1e08\u0003"+ - "+\u0015\u0000\u1e08\u1e09\u0003+\u0015\u0000\u1e09\u1e0a\u0003%\u0012"+ - "\u0000\u1e0a\u1e0b\u0003\u0007\u0003\u0000\u1e0b\u1e0c\u0003\u000b\u0005"+ - "\u0000\u1e0c\u1e0d\u0003\u000f\u0007\u0000\u1e0d\u057c\u0001\u0000\u0000"+ - "\u0000\u1e0e\u1e0f\u0003\u0011\b\u0000\u1e0f\u1e10\u0003\u0017\u000b\u0000"+ - "\u1e10\u1e11\u0003!\u0010\u0000\u1e11\u1e12\u0003\u0007\u0003\u0000\u1e12"+ - "\u1e13\u0003\u001d\u000e\u0000\u1e13\u1e14\u0003\u0011\b\u0000\u1e14\u1e15"+ - "\u0003/\u0017\u0000\u1e15\u1e16\u0003!\u0010\u0000"; - private static final String _serializedATNSegment3 = - "\u1e16\u1e17\u0003\u000b\u0005\u0000\u1e17\u057e\u0001\u0000\u0000\u0000"+ - "\u1e18\u1e19\u0003\u0011\b\u0000\u1e19\u1e1a\u0003\u0017\u000b\u0000\u1e1a"+ - "\u1e1b\u0003!\u0010\u0000\u1e1b\u1e1c\u0003\u0007\u0003\u0000\u1e1c\u1e1d"+ - "\u0003\u001d\u000e\u0000\u1e1d\u1e1e\u0003\u0011\b\u0000\u1e1e\u1e1f\u0003"+ - "/\u0017\u0000\u1e1f\u1e20\u0003!\u0010\u0000\u1e20\u1e21\u0003\u000b\u0005"+ - "\u0000\u1e21\u1e22\u0005_\u0000\u0000\u1e22\u1e23\u0003\u000f\u0007\u0000"+ - "\u1e23\u1e24\u00035\u001a\u0000\u1e24\u1e25\u0003-\u0016\u0000\u1e25\u1e26"+ - "\u0003)\u0014\u0000\u1e26\u1e27\u0003\u0007\u0003\u0000\u1e27\u0580\u0001"+ - "\u0000\u0000\u0000\u1e28\u1e29\u0003\u000b\u0005\u0000\u1e29\u1e2a\u0003"+ - "#\u0011\u0000\u1e2a\u1e2b\u0003\u001f\u000f\u0000\u1e2b\u1e2c\u0003\t"+ - "\u0004\u0000\u1e2c\u1e2d\u0003\u0017\u000b\u0000\u1e2d\u1e2e\u0003!\u0010"+ - "\u0000\u1e2e\u1e2f\u0003\u000f\u0007\u0000\u1e2f\u1e30\u0003\u0011\b\u0000"+ - "\u1e30\u1e31\u0003/\u0017\u0000\u1e31\u1e32\u0003!\u0010\u0000\u1e32\u1e33"+ - "\u0003\u000b\u0005\u0000\u1e33\u0582\u0001\u0000\u0000\u0000\u1e34\u1e35"+ - "\u0003+\u0015\u0000\u1e35\u1e36\u0003\u000f\u0007\u0000\u1e36\u1e37\u0003"+ - ")\u0014\u0000\u1e37\u1e38\u0003\u0017\u000b\u0000\u1e38\u1e39\u0003\u0007"+ - "\u0003\u0000\u1e39\u1e3a\u0003\u001d\u000e\u0000\u1e3a\u1e3b\u0003\u0011"+ - "\b\u0000\u1e3b\u1e3c\u0003/\u0017\u0000\u1e3c\u1e3d\u0003!\u0010\u0000"+ - "\u1e3d\u1e3e\u0003\u000b\u0005\u0000\u1e3e\u0584\u0001\u0000\u0000\u0000"+ - "\u1e3f\u1e40\u0003\r\u0006\u0000\u1e40\u1e41\u0003\u000f\u0007\u0000\u1e41"+ - "\u1e42\u0003+\u0015\u0000\u1e42\u1e43\u0003\u000f\u0007\u0000\u1e43\u1e44"+ - "\u0003)\u0014\u0000\u1e44\u1e45\u0003\u0017\u000b\u0000\u1e45\u1e46\u0003"+ - "\u0007\u0003\u0000\u1e46\u1e47\u0003\u001d\u000e\u0000\u1e47\u1e48\u0003"+ - "\u0011\b\u0000\u1e48\u1e49\u0003/\u0017\u0000\u1e49\u1e4a\u0003!\u0010"+ - "\u0000\u1e4a\u1e4b\u0003\u000b\u0005\u0000\u1e4b\u0586\u0001\u0000\u0000"+ - "\u0000\u1e4c\u1e4d\u0003\u0017\u000b\u0000\u1e4d\u1e4e\u0003!\u0010\u0000"+ - "\u1e4e\u1e4f\u0003\u0017\u000b\u0000\u1e4f\u1e50\u0003-\u0016\u0000\u1e50"+ - "\u1e51\u0003\u000b\u0005\u0000\u1e51\u1e52\u0003#\u0011\u0000\u1e52\u1e53"+ - "\u0003!\u0010\u0000\u1e53\u1e54\u0003\r\u0006\u0000\u1e54\u0588\u0001"+ - "\u0000\u0000\u0000\u1e55\u1e56\u0003\u001f\u000f\u0000\u1e56\u1e57\u0003"+ - "+\u0015\u0000\u1e57\u1e58\u0003\u0011\b\u0000\u1e58\u1e59\u0003/\u0017"+ - "\u0000\u1e59\u1e5a\u0003!\u0010\u0000\u1e5a\u1e5b\u0003\u000b\u0005\u0000"+ - "\u1e5b\u058a\u0001\u0000\u0000\u0000\u1e5c\u1e5d\u0003\u001f\u000f\u0000"+ - "\u1e5d\u1e5e\u0003\u0017\u000b\u0000\u1e5e\u1e5f\u0003!\u0010\u0000\u1e5f"+ - "\u1e60\u00031\u0018\u0000\u1e60\u1e61\u0003\u0011\b\u0000\u1e61\u1e62"+ - "\u0003/\u0017\u0000\u1e62\u1e63\u0003!\u0010\u0000\u1e63\u1e64\u0003\u000b"+ - "\u0005\u0000\u1e64\u058c\u0001\u0000\u0000\u0000\u1e65\u1e66\u0003\u001f"+ - "\u000f\u0000\u1e66\u1e67\u0003+\u0015\u0000\u1e67\u1e68\u0003-\u0016\u0000"+ - "\u1e68\u1e69\u00037\u001b\u0000\u1e69\u1e6a\u0003%\u0012\u0000\u1e6a\u1e6b"+ - "\u0003\u000f\u0007\u0000\u1e6b\u058e\u0001\u0000\u0000\u0000\u1e6c\u1e6d"+ - "\u0003\u001f\u000f\u0000\u1e6d\u1e6e\u0003+\u0015\u0000\u1e6e\u1e6f\u0003"+ - "+\u0015\u0000\u1e6f\u1e70\u0003%\u0012\u0000\u1e70\u1e71\u0003\u0007\u0003"+ - "\u0000\u1e71\u1e72\u0003\u000b\u0005\u0000\u1e72\u1e73\u0003\u000f\u0007"+ - "\u0000\u1e73\u0590\u0001\u0000\u0000\u0000\u1e74\u1e75\u0003\u001f\u000f"+ - "\u0000\u1e75\u1e76\u0003\u0011\b\u0000\u1e76\u1e77\u0003\u0017\u000b\u0000"+ - "\u1e77\u1e78\u0003!\u0010\u0000\u1e78\u1e79\u0003\u0007\u0003\u0000\u1e79"+ - "\u1e7a\u0003\u001d\u000e\u0000\u1e7a\u1e7b\u0003\u0011\b\u0000\u1e7b\u1e7c"+ - "\u0003/\u0017\u0000\u1e7c\u1e7d\u0003!\u0010\u0000\u1e7d\u1e7e\u0003\u000b"+ - "\u0005\u0000\u1e7e\u0592\u0001\u0000\u0000\u0000\u1e7f\u1e80\u0003\u001f"+ - "\u000f\u0000\u1e80\u1e81\u0003\u0011\b\u0000\u1e81\u1e82\u0003\u0017\u000b"+ - "\u0000\u1e82\u1e83\u0003!\u0010\u0000\u1e83\u1e84\u0003\u0007\u0003\u0000"+ - "\u1e84\u1e85\u0003\u001d\u000e\u0000\u1e85\u1e86\u0003\u0011\b\u0000\u1e86"+ - "\u1e87\u0003/\u0017\u0000\u1e87\u1e88\u0003!\u0010\u0000\u1e88\u1e89\u0003"+ - "\u000b\u0005\u0000\u1e89\u1e8a\u0005_\u0000\u0000\u1e8a\u1e8b\u0003\u000f"+ - "\u0007\u0000\u1e8b\u1e8c\u00035\u001a\u0000\u1e8c\u1e8d\u0003-\u0016\u0000"+ - "\u1e8d\u1e8e\u0003)\u0014\u0000\u1e8e\u1e8f\u0003\u0007\u0003\u0000\u1e8f"+ - "\u0594\u0001\u0000\u0000\u0000\u1e90\u1e91\u0003\u001f\u000f\u0000\u1e91"+ - "\u1e92\u0003\u0017\u000b\u0000\u1e92\u1e93\u0003!\u0010\u0000\u1e93\u1e94"+ - "\u0003\u0017\u000b\u0000\u1e94\u1e95\u0003-\u0016\u0000\u1e95\u1e96\u0003"+ - "\u000b\u0005\u0000\u1e96\u1e97\u0003#\u0011\u0000\u1e97\u1e98\u0003!\u0010"+ - "\u0000\u1e98\u1e99\u0003\r\u0006\u0000\u1e99\u0596\u0001\u0000\u0000\u0000"+ - "\u1e9a\u1e9b\u0003+\u0015\u0000\u1e9b\u1e9c\u0003#\u0011\u0000\u1e9c\u1e9d"+ - "\u0003)\u0014\u0000\u1e9d\u1e9e\u0003-\u0016\u0000\u1e9e\u1e9f\u0003#"+ - "\u0011\u0000\u1e9f\u1ea0\u0003%\u0012\u0000\u1ea0\u0598\u0001\u0000\u0000"+ - "\u0000\u1ea1\u1ea2\u0003%\u0012\u0000\u1ea2\u1ea3\u0003\u0007\u0003\u0000"+ - "\u1ea3\u1ea4\u0003)\u0014\u0000\u1ea4\u1ea5\u0003\u0007\u0003\u0000\u1ea5"+ - "\u1ea6\u0003\u001d\u000e\u0000\u1ea6\u1ea7\u0003\u001d\u000e\u0000\u1ea7"+ - "\u1ea8\u0003\u000f\u0007\u0000\u1ea8\u1ea9\u0003\u001d\u000e\u0000\u1ea9"+ - "\u059a\u0001\u0000\u0000\u0000\u1eaa\u1eab\u0003\u0015\n\u0000\u1eab\u1eac"+ - "\u00037\u001b\u0000\u1eac\u1ead\u0003%\u0012\u0000\u1ead\u1eae\u0003#"+ - "\u0011\u0000\u1eae\u1eaf\u0003-\u0016\u0000\u1eaf\u1eb0\u0003\u0015\n"+ - "\u0000\u1eb0\u1eb1\u0003\u000f\u0007\u0000\u1eb1\u1eb2\u0003-\u0016\u0000"+ - "\u1eb2\u1eb3\u0003\u0017\u000b\u0000\u1eb3\u1eb4\u0003\u000b\u0005\u0000"+ - "\u1eb4\u1eb5\u0003\u0007\u0003\u0000\u1eb5\u1eb6\u0003\u001d\u000e\u0000"+ - "\u1eb6\u059c\u0001\u0000\u0000\u0000\u1eb7\u1eb8\u0003+\u0015\u0000\u1eb8"+ - "\u1eb9\u0003\u0007\u0003\u0000\u1eb9\u1eba\u0003\u0011\b\u0000\u1eba\u1ebb"+ - "\u0003\u000f\u0007\u0000\u1ebb\u059e\u0001\u0000\u0000\u0000\u1ebc\u1ebd"+ - "\u0003)\u0014\u0000\u1ebd\u1ebe\u0003\u000f\u0007\u0000\u1ebe\u1ebf\u0003"+ - "+\u0015\u0000\u1ebf\u1ec0\u0003-\u0016\u0000\u1ec0\u1ec1\u0003)\u0014"+ - "\u0000\u1ec1\u1ec2\u0003\u0017\u000b\u0000\u1ec2\u1ec3\u0003\u000b\u0005"+ - "\u0000\u1ec3\u1ec4\u0003-\u0016\u0000\u1ec4\u1ec5\u0003\u000f\u0007\u0000"+ - "\u1ec5\u1ec6\u0003\r\u0006\u0000\u1ec6\u05a0\u0001\u0000\u0000\u0000\u1ec7"+ - "\u1ec8\u0003/\u0017\u0000\u1ec8\u1ec9\u0003!\u0010\u0000\u1ec9\u1eca\u0003"+ - "+\u0015\u0000\u1eca\u1ecb\u0003\u0007\u0003\u0000\u1ecb\u1ecc\u0003\u0011"+ - "\b\u0000\u1ecc\u1ecd\u0003\u000f\u0007\u0000\u1ecd\u05a2\u0001\u0000\u0000"+ - "\u0000\u1ece\u1ecf\u0003\t\u0004\u0000\u1ecf\u1ed0\u0003\u0007\u0003\u0000"+ - "\u1ed0\u1ed1\u0003+\u0015\u0000\u1ed1\u1ed2\u0003\u000f\u0007\u0000\u1ed2"+ - "\u1ed3\u0003-\u0016\u0000\u1ed3\u1ed4\u00037\u001b\u0000\u1ed4\u1ed5\u0003"+ - "%\u0012\u0000\u1ed5\u1ed6\u0003\u000f\u0007\u0000\u1ed6\u05a4\u0001\u0000"+ - "\u0000\u0000\u1ed7\u1ed8\u0003\u0017\u000b\u0000\u1ed8\u1ed9\u0003\u0011"+ - "\b\u0000\u1ed9\u05a6\u0001\u0000\u0000\u0000\u1eda\u1edb\u0003\u001d\u000e"+ - "\u0000\u1edb\u1edc\u0003#\u0011\u0000\u1edc\u1edd\u0003\u000b\u0005\u0000"+ - "\u1edd\u1ede\u0003\u0007\u0003\u0000\u1ede\u1edf\u0003\u001d\u000e\u0000"+ - "\u1edf\u1ee0\u0003\u000f\u0007\u0000\u1ee0\u05a8\u0001\u0000\u0000\u0000"+ - "\u1ee1\u1ee2\u0003\u001d\u000e\u0000\u1ee2\u1ee3\u0003\u000b\u0005\u0000"+ - "\u1ee3\u1ee4\u0005_\u0000\u0000\u1ee4\u1ee5\u0003\u000b\u0005\u0000\u1ee5"+ - "\u1ee6\u0003#\u0011\u0000\u1ee6\u1ee7\u0003\u001d\u000e\u0000\u1ee7\u1ee8"+ - "\u0003\u001d\u000e\u0000\u1ee8\u1ee9\u0003\u0007\u0003\u0000\u1ee9\u1eea"+ - "\u0003-\u0016\u0000\u1eea\u1eeb\u0003\u000f\u0007\u0000\u1eeb\u05aa\u0001"+ - "\u0000\u0000\u0000\u1eec\u1eed\u0003\u001d\u000e\u0000\u1eed\u1eee\u0003"+ - "\u000b\u0005\u0000\u1eee\u1eef\u0005_\u0000\u0000\u1eef\u1ef0\u0003\u000b"+ - "\u0005\u0000\u1ef0\u1ef1\u0003-\u0016\u0000\u1ef1\u1ef2\u00037\u001b\u0000"+ - "\u1ef2\u1ef3\u0003%\u0012\u0000\u1ef3\u1ef4\u0003\u000f\u0007\u0000\u1ef4"+ - "\u05ac\u0001\u0000\u0000\u0000\u1ef5\u1ef6\u0003%\u0012\u0000\u1ef6\u1ef7"+ - "\u0003)\u0014\u0000\u1ef7\u1ef8\u0003#\u0011\u0000\u1ef8\u1ef9\u00031"+ - "\u0018\u0000\u1ef9\u1efa\u0003\u0017\u000b\u0000\u1efa\u1efb\u0003\r\u0006"+ - "\u0000\u1efb\u1efc\u0003\u000f\u0007\u0000\u1efc\u1efd\u0003)\u0014\u0000"+ - "\u1efd\u05ae\u0001\u0000\u0000\u0000\u1efe\u1eff\u00031\u0018\u0000\u1eff"+ - "\u1f00\u0003\u000f\u0007\u0000\u1f00\u1f01\u0003)\u0014\u0000\u1f01\u1f02"+ - "\u0003+\u0015\u0000\u1f02\u1f03\u0003\u0017\u000b\u0000\u1f03\u1f04\u0003"+ - "#\u0011\u0000\u1f04\u1f05\u0003!\u0010\u0000\u1f05\u05b0\u0001\u0000\u0000"+ - "\u0000\u1f06\u1f07\u0003\u0007\u0003\u0000\u1f07\u1f08\u0003\u001d\u000e"+ - "\u0000\u1f08\u1f09\u0003\u001d\u000e\u0000\u1f09\u1f0a\u0003#\u0011\u0000"+ - "\u1f0a\u1f0b\u00033\u0019\u0000\u1f0b\u1f0c\u0005_\u0000\u0000\u1f0c\u1f0d"+ - "\u0003\u000b\u0005\u0000\u1f0d\u1f0e\u0003#\u0011\u0000\u1f0e\u1f0f\u0003"+ - "!\u0010\u0000\u1f0f\u1f10\u0003!\u0010\u0000\u1f10\u1f11\u0003\u000f\u0007"+ - "\u0000\u1f11\u1f12\u0003\u000b\u0005\u0000\u1f12\u1f13\u0003-\u0016\u0000"+ - "\u1f13\u1f14\u0003\u0017\u000b\u0000\u1f14\u1f15\u0003#\u0011\u0000\u1f15"+ - "\u1f16\u0003!\u0010\u0000\u1f16\u1f17\u0003+\u0015\u0000\u1f17\u05b2\u0001"+ - "\u0000\u0000\u0000\u1f18\u1f19\u0003\u0017\u000b\u0000\u1f19\u1f1a\u0003"+ - "+\u0015\u0000\u1f1a\u1f1b\u0005_\u0000\u0000\u1f1b\u1f1c\u0003-\u0016"+ - "\u0000\u1f1c\u1f1d\u0003\u000f\u0007\u0000\u1f1d\u1f1e\u0003\u001f\u000f"+ - "\u0000\u1f1e\u1f1f\u0003%\u0012\u0000\u1f1f\u1f20\u0003\u001d\u000e\u0000"+ - "\u1f20\u1f21\u0003\u0007\u0003\u0000\u1f21\u1f22\u0003-\u0016\u0000\u1f22"+ - "\u1f23\u0003\u000f\u0007\u0000\u1f23\u05b4\u0001\u0000\u0000\u0000\u1f24"+ - "\u1f25\u0003\u000f\u0007\u0000\u1f25\u1f26\u00031\u0018\u0000\u1f26\u1f27"+ - "\u0003\u000f\u0007\u0000\u1f27\u1f28\u0003!\u0010\u0000\u1f28\u1f29\u0003"+ - "-\u0016\u0000\u1f29\u05b6\u0001\u0000\u0000\u0000\u1f2a\u1f2b\u00033\u0019"+ - "\u0000\u1f2b\u1f2c\u0003)\u0014\u0000\u1f2c\u1f2d\u0003\u0007\u0003\u0000"+ - "\u1f2d\u1f2e\u0003%\u0012\u0000\u1f2e\u1f2f\u0003%\u0012\u0000\u1f2f\u1f30"+ - "\u0003\u000f\u0007\u0000\u1f30\u1f31\u0003)\u0014\u0000\u1f31\u05b8\u0001"+ - "\u0000\u0000\u0000\u1f32\u1f33\u0003+\u0015\u0000\u1f33\u1f34\u0003\u000f"+ - "\u0007\u0000\u1f34\u1f35\u0003)\u0014\u0000\u1f35\u1f36\u00031\u0018\u0000"+ - "\u1f36\u1f37\u0003\u000f\u0007\u0000\u1f37\u1f38\u0003)\u0014\u0000\u1f38"+ - "\u05ba\u0001\u0000\u0000\u0000\u1f39\u1f3a\u0003\t\u0004\u0000\u1f3a\u1f3b"+ - "\u0003-\u0016\u0000\u1f3b\u1f3c\u0003)\u0014\u0000\u1f3c\u1f3d\u0003\u000f"+ - "\u0007\u0000\u1f3d\u1f3e\u0003\u000f\u0007\u0000\u1f3e\u05bc\u0001\u0000"+ - "\u0000\u0000\u1f3f\u1f40\u0003\u0015\n\u0000\u1f40\u1f41\u0003\u0007\u0003"+ - "\u0000\u1f41\u1f42\u0003+\u0015\u0000\u1f42\u1f43\u0003\u0015\n\u0000"+ - "\u1f43\u05be\u0001\u0000\u0000\u0000\u1f44\u1f45\u0003\u0013\t\u0000\u1f45"+ - "\u1f46\u0003\u0017\u000b\u0000\u1f46\u1f47\u0003+\u0015\u0000\u1f47\u1f48"+ - "\u0003-\u0016\u0000\u1f48\u05c0\u0001\u0000\u0000\u0000\u1f49\u1f4a\u0003"+ - "+\u0015\u0000\u1f4a\u1f4b\u0003%\u0012\u0000\u1f4b\u1f4c\u0003\u0013\t"+ - "\u0000\u1f4c\u1f4d\u0003\u0017\u000b\u0000\u1f4d\u1f4e\u0003+\u0015\u0000"+ - "\u1f4e\u1f4f\u0003-\u0016\u0000\u1f4f\u05c2\u0001\u0000\u0000\u0000\u1f50"+ - "\u1f51\u0003\u0013\t\u0000\u1f51\u1f52\u0003\u0017\u000b\u0000\u1f52\u1f53"+ - "\u0003!\u0010\u0000\u1f53\u05c4\u0001\u0000\u0000\u0000\u1f54\u1f55\u0003"+ - "\t\u0004\u0000\u1f55\u1f56\u0003)\u0014\u0000\u1f56\u1f57\u0003\u0017"+ - "\u000b\u0000\u1f57\u1f58\u0003!\u0010\u0000\u1f58\u05c6\u0001\u0000\u0000"+ - "\u0000\u1f59\u1f5a\u0003\u000b\u0005\u0000\u1f5a\u1f5b\u0003#\u0011\u0000"+ - "\u1f5b\u1f5c\u0003!\u0010\u0000\u1f5c\u1f5d\u0003\u000b\u0005\u0000\u1f5d"+ - "\u1f5e\u0003/\u0017\u0000\u1f5e\u1f5f\u0003)\u0014\u0000\u1f5f\u1f60\u0003"+ - ")\u0014\u0000\u1f60\u1f61\u0003\u000f\u0007\u0000\u1f61\u1f62\u0003!\u0010"+ - "\u0000\u1f62\u1f63\u0003-\u0016\u0000\u1f63\u1f64\u0003\u001d\u000e\u0000"+ - "\u1f64\u1f65\u00037\u001b\u0000\u1f65\u05c8\u0001\u0000\u0000\u0000\u1f66"+ - "\u1f67\u0003\u0017\u000b\u0000\u1f67\u1f68\u0003!\u0010\u0000\u1f68\u1f69"+ - "\u0003\u001d\u000e\u0000\u1f69\u1f6a\u0003\u0017\u000b\u0000\u1f6a\u1f6b"+ - "\u0003!\u0010\u0000\u1f6b\u1f6c\u0003\u000f\u0007\u0000\u1f6c\u05ca\u0001"+ - "\u0000\u0000\u0000\u1f6d\u1f6e\u0003\u001f\u000f\u0000\u1f6e\u1f6f\u0003"+ - "\u0007\u0003\u0000\u1f6f\u1f70\u0003-\u0016\u0000\u1f70\u1f71\u0003\u000f"+ - "\u0007\u0000\u1f71\u1f72\u0003)\u0014\u0000\u1f72\u1f73\u0003\u0017\u000b"+ - "\u0000\u1f73\u1f74\u0003\u0007\u0003\u0000\u1f74\u1f75\u0003\u001d\u000e"+ - "\u0000\u1f75\u1f76\u0003\u0017\u000b\u0000\u1f76\u1f77\u00039\u001c\u0000"+ - "\u1f77\u1f78\u0003\u000f\u0007\u0000\u1f78\u1f79\u0003\r\u0006\u0000\u1f79"+ - "\u05cc\u0001\u0000\u0000\u0000\u1f7a\u1f7b\u0003\u001d\u000e\u0000\u1f7b"+ - "\u1f7c\u0003\u000f\u0007\u0000\u1f7c\u1f7d\u0003\u0011\b\u0000\u1f7d\u1f7e"+ - "\u0003-\u0016\u0000\u1f7e\u1f7f\u0003\u0007\u0003\u0000\u1f7f\u1f80\u0003"+ - ")\u0014\u0000\u1f80\u1f81\u0003\u0013\t\u0000\u1f81\u05ce\u0001\u0000"+ - "\u0000\u0000\u1f82\u1f83\u0003)\u0014\u0000\u1f83\u1f84\u0003\u0017\u000b"+ - "\u0000\u1f84\u1f85\u0003\u0013\t\u0000\u1f85\u1f86\u0003\u0015\n\u0000"+ - "\u1f86\u1f87\u0003-\u0016\u0000\u1f87\u1f88\u0003\u0007\u0003\u0000\u1f88"+ - "\u1f89\u0003)\u0014\u0000\u1f89\u1f8a\u0003\u0013\t\u0000\u1f8a\u05d0"+ - "\u0001\u0000\u0000\u0000\u1f8b\u1f8c\u0003\u000b\u0005\u0000\u1f8c\u1f8d"+ - "\u0003#\u0011\u0000\u1f8d\u1f8e\u0003\u001f\u000f\u0000\u1f8e\u1f8f\u0003"+ - "\u001f\u000f\u0000\u1f8f\u1f90\u0003/\u0017\u0000\u1f90\u1f91\u0003-\u0016"+ - "\u0000\u1f91\u1f92\u0003\u0007\u0003\u0000\u1f92\u1f93\u0003-\u0016\u0000"+ - "\u1f93\u1f94\u0003#\u0011\u0000\u1f94\u1f95\u0003)\u0014\u0000\u1f95\u05d2"+ - "\u0001\u0000\u0000\u0000\u1f96\u1f97\u0003!\u0010\u0000\u1f97\u1f98\u0003"+ - "\u000f\u0007\u0000\u1f98\u1f99\u0003\u0013\t\u0000\u1f99\u1f9a\u0003\u0007"+ - "\u0003\u0000\u1f9a\u1f9b\u0003-\u0016\u0000\u1f9b\u1f9c\u0003#\u0011\u0000"+ - "\u1f9c\u1f9d\u0003)\u0014\u0000\u1f9d\u05d4\u0001\u0000\u0000\u0000\u1f9e"+ - "\u1f9f\u0003\u0015\n\u0000\u1f9f\u1fa0\u0003\u0007\u0003\u0000\u1fa0\u1fa1"+ - "\u0003+\u0015\u0000\u1fa1\u1fa2\u0003\u0015\n\u0000\u1fa2\u1fa3\u0003"+ - "\u000f\u0007\u0000\u1fa3\u1fa4\u0003+\u0015\u0000\u1fa4\u05d6\u0001\u0000"+ - "\u0000\u0000\u1fa5\u1fa6\u0003\u001f\u000f\u0000\u1fa6\u1fa7\u0003\u000f"+ - "\u0007\u0000\u1fa7\u1fa8\u0003)\u0014\u0000\u1fa8\u1fa9\u0003\u0013\t"+ - "\u0000\u1fa9\u1faa\u0003\u000f\u0007\u0000\u1faa\u1fab\u0003+\u0015\u0000"+ - "\u1fab\u05d8\u0001\u0000\u0000\u0000\u1fac\u1fad\u0003\u0011\b\u0000\u1fad"+ - "\u1fae\u0003\u0007\u0003\u0000\u1fae\u1faf\u0003\u001f\u000f\u0000\u1faf"+ - "\u1fb0\u0003\u0017\u000b\u0000\u1fb0\u1fb1\u0003\u001d\u000e\u0000\u1fb1"+ - "\u1fb2\u00037\u001b\u0000\u1fb2\u05da\u0001\u0000\u0000\u0000\u1fb3\u1fb4"+ - "\u0003%\u0012\u0000\u1fb4\u1fb5\u0003#\u0011\u0000\u1fb5\u1fb6\u0003\u001d"+ - "\u000e\u0000\u1fb6\u1fb7\u0003\u0017\u000b\u0000\u1fb7\u1fb8\u0003\u000b"+ - "\u0005\u0000\u1fb8\u1fb9\u00037\u001b\u0000\u1fb9\u05dc\u0001\u0000\u0000"+ - "\u0000\u1fba\u1fbb\u0003#\u0011\u0000\u1fbb\u1fbc\u00033\u0019\u0000\u1fbc"+ - "\u1fbd\u0003!\u0010\u0000\u1fbd\u1fbe\u0003\u000f\u0007\u0000\u1fbe\u1fbf"+ - "\u0003\r\u0006\u0000\u1fbf\u05de\u0001\u0000\u0000\u0000\u1fc0\u1fc1\u0003"+ - "\u0007\u0003\u0000\u1fc1\u1fc2\u0003\t\u0004\u0000\u1fc2\u1fc3\u0003+"+ - "\u0015\u0000\u1fc3\u1fc4\u0003-\u0016\u0000\u1fc4\u1fc5\u0003\u0017\u000b"+ - "\u0000\u1fc5\u1fc6\u0003\u001f\u000f\u0000\u1fc6\u1fc7\u0003\u000f\u0007"+ - "\u0000\u1fc7\u05e0\u0001\u0000\u0000\u0000\u1fc8\u1fc9\u0003\t\u0004\u0000"+ - "\u1fc9\u1fca\u0003\u0017\u000b\u0000\u1fca\u1fcb\u0003\u0013\t\u0000\u1fcb"+ - "\u1fcc\u0003+\u0015\u0000\u1fcc\u1fcd\u0003\u000f\u0007\u0000\u1fcd\u1fce"+ - "\u0003)\u0014\u0000\u1fce\u1fcf\u0003\u0017\u000b\u0000\u1fcf\u1fd0\u0003"+ - "\u0007\u0003\u0000\u1fd0\u1fd1\u0003\u001d\u000e\u0000\u1fd1\u05e2\u0001"+ - "\u0000\u0000\u0000\u1fd2\u1fd3\u0003\t\u0004\u0000\u1fd3\u1fd4\u0003\u0017"+ - "\u000b\u0000\u1fd4\u1fd5\u0003-\u0016\u0000\u1fd5\u1fd6\u0005 \u0000\u0000"+ - "\u1fd6\u1fd7\u00031\u0018\u0000\u1fd7\u1fd8\u0003\u0007\u0003\u0000\u1fd8"+ - "\u1fd9\u0003)\u0014\u0000\u1fd9\u1fda\u00037\u001b\u0000\u1fda\u1fdb\u0003"+ - "\u0017\u000b\u0000\u1fdb\u1fdc\u0003!\u0010\u0000\u1fdc\u1fdd\u0003\u0013"+ - "\t\u0000\u1fdd\u05e4\u0001\u0000\u0000\u0000\u1fde\u1fdf\u0003\t\u0004"+ - "\u0000\u1fdf\u1fe0\u0003#\u0011\u0000\u1fe0\u1fe1\u0003#\u0011\u0000\u1fe1"+ - "\u1fe2\u0003\u001d\u000e\u0000\u1fe2\u05e6\u0001\u0000\u0000\u0000\u1fe3"+ - "\u1fe4\u0003\t\u0004\u0000\u1fe4\u1fe5\u0003#\u0011\u0000\u1fe5\u1fe6"+ - "\u00035\u001a\u0000\u1fe6\u05e8\u0001\u0000\u0000\u0000\u1fe7\u1fe8\u0003"+ - "\t\u0004\u0000\u1fe8\u1fe9\u00037\u001b\u0000\u1fe9\u1fea\u0003-\u0016"+ - "\u0000\u1fea\u1feb\u0003\u000f\u0007\u0000\u1feb\u1fec\u0003\u0007\u0003"+ - "\u0000\u1fec\u05ea\u0001\u0000\u0000\u0000\u1fed\u1fee\u0003\u000b\u0005"+ - "\u0000\u1fee\u1fef\u0003\u0015\n\u0000\u1fef\u1ff0\u0003\u0007\u0003\u0000"+ - "\u1ff0\u1ff1\u0003)\u0014\u0000\u1ff1\u1ff2\u0003\u0007\u0003\u0000\u1ff2"+ - "\u1ff3\u0003\u000b\u0005\u0000\u1ff3\u1ff4\u0003-\u0016\u0000\u1ff4\u1ff5"+ - "\u0003\u000f\u0007\u0000\u1ff5\u1ff6\u0003)\u0014\u0000\u1ff6\u1ff7\u0005"+ - " \u0000\u0000\u1ff7\u1ff8\u00031\u0018\u0000\u1ff8\u1ff9\u0003\u0007\u0003"+ - "\u0000\u1ff9\u1ffa\u0003)\u0014\u0000\u1ffa\u1ffb\u00037\u001b\u0000\u1ffb"+ - "\u1ffc\u0003\u0017\u000b\u0000\u1ffc\u1ffd\u0003!\u0010\u0000\u1ffd\u1ffe"+ - "\u0003\u0013\t\u0000\u1ffe\u05ec\u0001\u0000\u0000\u0000\u1fff\u2000\u0003"+ - "\u000b\u0005\u0000\u2000\u2001\u0003\u0017\u000b\u0000\u2001\u2002\u0003"+ - "\r\u0006\u0000\u2002\u2003\u0003)\u0014\u0000\u2003\u05ee\u0001\u0000"+ - "\u0000\u0000\u2004\u2005\u0003\u000b\u0005\u0000\u2005\u2006\u0003\u0017"+ - "\u000b\u0000\u2006\u2007\u0003)\u0014\u0000\u2007\u2008\u0003\u000b\u0005"+ - "\u0000\u2008\u2009\u0003\u001d\u000e\u0000\u2009\u200a\u0003\u000f\u0007"+ - "\u0000\u200a\u05f0\u0001\u0000\u0000\u0000\u200b\u200c\u0003\u0011\b\u0000"+ - "\u200c\u200d\u0003\u001d\u000e\u0000\u200d\u200e\u0003#\u0011\u0000\u200e"+ - "\u200f\u0003\u0007\u0003\u0000\u200f\u2010\u0003-\u0016\u0000\u2010\u2011"+ - "\u00054\u0000\u0000\u2011\u05f2\u0001\u0000\u0000\u0000\u2012\u2013\u0003"+ - "\u0011\b\u0000\u2013\u2014\u0003\u001d\u000e\u0000\u2014\u2015\u0003#"+ - "\u0011\u0000\u2015\u2016\u0003\u0007\u0003\u0000\u2016\u2017\u0003-\u0016"+ - "\u0000\u2017\u2018\u00058\u0000\u0000\u2018\u05f4\u0001\u0000\u0000\u0000"+ - "\u2019\u201a\u0003\u0017\u000b\u0000\u201a\u201b\u0003!\u0010\u0000\u201b"+ - "\u201c\u0003\u000f\u0007\u0000\u201c\u201d\u0003-\u0016\u0000\u201d\u05f6"+ - "\u0001\u0000\u0000\u0000\u201e\u201f\u0003\u0017\u000b\u0000\u201f\u2020"+ - "\u0003!\u0010\u0000\u2020\u2021\u0003-\u0016\u0000\u2021\u2022\u00052"+ - "\u0000\u0000\u2022\u05f8\u0001\u0000\u0000\u0000\u2023\u2024\u0003\u0017"+ - "\u000b\u0000\u2024\u2025\u0003!\u0010\u0000\u2025\u2026\u0003-\u0016\u0000"+ - "\u2026\u2027\u00054\u0000\u0000\u2027\u05fa\u0001\u0000\u0000\u0000\u2028"+ - "\u2029\u0003\u0017\u000b\u0000\u2029\u202a\u0003!\u0010\u0000\u202a\u202b"+ - "\u0003-\u0016\u0000\u202b\u202c\u00058\u0000\u0000\u202c\u05fc\u0001\u0000"+ - "\u0000\u0000\u202d\u202e\u0003\u0019\f\u0000\u202e\u202f\u0003+\u0015"+ - "\u0000\u202f\u2030\u0003#\u0011\u0000\u2030\u2031\u0003!\u0010\u0000\u2031"+ - "\u05fe\u0001\u0000\u0000\u0000\u2032\u2033\u0003\u0019\f\u0000\u2033\u2034"+ - "\u0003+\u0015\u0000\u2034\u2035\u0003#\u0011\u0000\u2035\u2036\u0003!"+ - "\u0010\u0000\u2036\u2037\u0003\t\u0004\u0000\u2037\u0600\u0001\u0000\u0000"+ - "\u0000\u2038\u2039\u0003\u001d\u000e\u0000\u2039\u203a\u0003\u0017\u000b"+ - "\u0000\u203a\u203b\u0003!\u0010\u0000\u203b\u203c\u0003\u000f\u0007\u0000"+ - "\u203c\u0602\u0001\u0000\u0000\u0000\u203d\u203e\u0003\u001d\u000e\u0000"+ - "\u203e\u203f\u0003+\u0015\u0000\u203f\u2040\u0003\u000f\u0007\u0000\u2040"+ - "\u2041\u0003\u0013\t\u0000\u2041\u0604\u0001\u0000\u0000\u0000\u2042\u2043"+ - "\u0003\u001f\u000f\u0000\u2043\u2044\u0003\u0007\u0003\u0000\u2044\u2045"+ - "\u0003\u000b\u0005\u0000\u2045\u2046\u0003\u0007\u0003\u0000\u2046\u2047"+ - "\u0003\r\u0006\u0000\u2047\u2048\u0003\r\u0006\u0000\u2048\u2049\u0003"+ - ")\u0014\u0000\u2049\u0606\u0001\u0000\u0000\u0000\u204a\u204b\u0003\u001f"+ - "\u000f\u0000\u204b\u204c\u0003\u0007\u0003\u0000\u204c\u204d\u0003\u000b"+ - "\u0005\u0000\u204d\u204e\u0003\u0007\u0003\u0000\u204e\u204f\u0003\r\u0006"+ - "\u0000\u204f\u2050\u0003\r\u0006\u0000\u2050\u2051\u0003)\u0014\u0000"+ - "\u2051\u2052\u00058\u0000\u0000\u2052\u0608\u0001\u0000\u0000\u0000\u2053"+ - "\u2054\u0003\u001f\u000f\u0000\u2054\u2055\u0003#\u0011\u0000\u2055\u2056"+ - "\u0003!\u0010\u0000\u2056\u2057\u0003\u000f\u0007\u0000\u2057\u2058\u0003"+ - "7\u001b\u0000\u2058\u060a\u0001\u0000\u0000\u0000\u2059\u205a\u0003%\u0012"+ - "\u0000\u205a\u205b\u0003\u0013\t\u0000\u205b\u205c\u0005_\u0000\u0000"+ - "\u205c\u205d\u0003\u001d\u000e\u0000\u205d\u205e\u0003+\u0015\u0000\u205e"+ - "\u205f\u0003!\u0010\u0000\u205f\u060c\u0001\u0000\u0000\u0000\u2060\u2061"+ - "\u0003%\u0012\u0000\u2061\u2062\u0003#\u0011\u0000\u2062\u2063\u0003\u0017"+ - "\u000b\u0000\u2063\u2064\u0003!\u0010\u0000\u2064\u2065\u0003-\u0016\u0000"+ - "\u2065\u060e\u0001\u0000\u0000\u0000\u2066\u2067\u0003%\u0012\u0000\u2067"+ - "\u2068\u0003#\u0011\u0000\u2068\u2069\u0003\u001d\u000e\u0000\u2069\u206a"+ - "\u00037\u001b\u0000\u206a\u206b\u0003\u0013\t\u0000\u206b\u206c\u0003"+ - "#\u0011\u0000\u206c\u206d\u0003!\u0010\u0000\u206d\u0610\u0001\u0000\u0000"+ - "\u0000\u206e\u206f\u0003)\u0014\u0000\u206f\u2070\u0003\u000f\u0007\u0000"+ - "\u2070\u2071\u0003\u001d\u000e\u0000\u2071\u2072\u0003-\u0016\u0000\u2072"+ - "\u2073\u0003\u0017\u000b\u0000\u2073\u2074\u0003\u001f\u000f\u0000\u2074"+ - "\u2075\u0003\u000f\u0007\u0000\u2075\u0612\u0001\u0000\u0000\u0000\u2076"+ - "\u2077\u0003+\u0015\u0000\u2077\u2078\u0003\u000f\u0007\u0000\u2078\u2079"+ - "\u0003)\u0014\u0000\u2079\u207a\u0003\u0017\u000b\u0000\u207a\u207b\u0003"+ - "\u0007\u0003\u0000\u207b\u207c\u0003\u001d\u000e\u0000\u207c\u0614\u0001"+ - "\u0000\u0000\u0000\u207d\u207e\u0003+\u0015\u0000\u207e\u207f\u0003\u000f"+ - "\u0007\u0000\u207f\u2080\u0003)\u0014\u0000\u2080\u2081\u0003\u0017\u000b"+ - "\u0000\u2081\u2082\u0003\u0007\u0003\u0000\u2082\u2083\u0003\u001d\u000e"+ - "\u0000\u2083\u2084\u00052\u0000\u0000\u2084\u0616\u0001\u0000\u0000\u0000"+ - "\u2085\u2086\u0003+\u0015\u0000\u2086\u2087\u0003\u000f\u0007\u0000\u2087"+ - "\u2088\u0003)\u0014\u0000\u2088\u2089\u0003\u0017\u000b\u0000\u2089\u208a"+ - "\u0003\u0007\u0003\u0000\u208a\u208b\u0003\u001d\u000e\u0000\u208b\u208c"+ - "\u00054\u0000\u0000\u208c\u0618\u0001\u0000\u0000\u0000\u208d\u208e\u0003"+ - "+\u0015\u0000\u208e\u208f\u0003\u000f\u0007\u0000\u208f\u2090\u0003)\u0014"+ - "\u0000\u2090\u2091\u0003\u0017\u000b\u0000\u2091\u2092\u0003\u0007\u0003"+ - "\u0000\u2092\u2093\u0003\u001d\u000e\u0000\u2093\u2094\u00058\u0000\u0000"+ - "\u2094\u061a\u0001\u0000\u0000\u0000\u2095\u2096\u0003+\u0015\u0000\u2096"+ - "\u2097\u0003\u001f\u000f\u0000\u2097\u2098\u0003\u0007\u0003\u0000\u2098"+ - "\u2099\u0003\u001d\u000e\u0000\u2099\u209a\u0003\u001d\u000e\u0000\u209a"+ - "\u209b\u0003+\u0015\u0000\u209b\u209c\u0003\u000f\u0007\u0000\u209c\u209d"+ - "\u0003)\u0014\u0000\u209d\u209e\u0003\u0017\u000b\u0000\u209e\u209f\u0003"+ - "\u0007\u0003\u0000\u209f\u20a0\u0003\u001d\u000e\u0000\u20a0\u061c\u0001"+ - "\u0000\u0000\u0000\u20a1\u20a2\u0003+\u0015\u0000\u20a2\u20a3\u0003-\u0016"+ - "\u0000\u20a3\u20a4\u0003+\u0015\u0000\u20a4\u20a5\u0003-\u0016\u0000\u20a5"+ - "\u20a6\u0003\u000f\u0007\u0000\u20a6\u20a7\u0003\u001f\u000f\u0000\u20a7"+ - "\u061e\u0001\u0000\u0000\u0000\u20a8\u20a9\u0003-\u0016\u0000\u20a9\u20aa"+ - "\u0003\u000f\u0007\u0000\u20aa\u20ab\u00035\u001a\u0000\u20ab\u20ac\u0003"+ - "-\u0016\u0000\u20ac\u0620\u0001\u0000\u0000\u0000\u20ad\u20ae\u0003-\u0016"+ - "\u0000\u20ae\u20af\u0003\u0017\u000b\u0000\u20af\u20b0\u0003\u001f\u000f"+ - "\u0000\u20b0\u20b1\u0003\u000f\u0007\u0000\u20b1\u20b2\u0003+\u0015\u0000"+ - "\u20b2\u20b3\u0003-\u0016\u0000\u20b3\u20b4\u0003\u0007\u0003\u0000\u20b4"+ - "\u20b5\u0003\u001f\u000f\u0000\u20b5\u20b6\u0003%\u0012\u0000\u20b6\u20b7"+ - "\u0003-\u0016\u0000\u20b7\u20b8\u00039\u001c\u0000\u20b8\u0622\u0001\u0000"+ - "\u0000\u0000\u20b9\u20ba\u0003-\u0016\u0000\u20ba\u20bb\u0003\u0017\u000b"+ - "\u0000\u20bb\u20bc\u0003\u001f\u000f\u0000\u20bc\u20bd\u0003\u000f\u0007"+ - "\u0000\u20bd\u20be\u0003-\u0016\u0000\u20be\u20bf\u00039\u001c\u0000\u20bf"+ - "\u0624\u0001\u0000\u0000\u0000\u20c0\u20c1\u0003-\u0016\u0000\u20c1\u20c2"+ - "\u0003+\u0015\u0000\u20c2\u20c3\u0003\'\u0013\u0000\u20c3\u20c4\u0003"+ - "/\u0017\u0000\u20c4\u20c5\u0003\u000f\u0007\u0000\u20c5\u20c6\u0003)\u0014"+ - "\u0000\u20c6\u20c7\u00037\u001b\u0000\u20c7\u0626\u0001\u0000\u0000\u0000"+ - "\u20c8\u20c9\u0003-\u0016\u0000\u20c9\u20ca\u0003+\u0015\u0000\u20ca\u20cb"+ - "\u00031\u0018\u0000\u20cb\u20cc\u0003\u000f\u0007\u0000\u20cc\u20cd\u0003"+ - "\u000b\u0005\u0000\u20cd\u20ce\u0003-\u0016\u0000\u20ce\u20cf\u0003#\u0011"+ - "\u0000\u20cf\u20d0\u0003)\u0014\u0000\u20d0\u0628\u0001\u0000\u0000\u0000"+ - "\u20d1\u20d2\u0003-\u0016\u0000\u20d2\u20d3\u00035\u001a\u0000\u20d3\u20d4"+ - "\u0003\u0017\u000b\u0000\u20d4\u20d5\u0003\r\u0006\u0000\u20d5\u20d6\u0005"+ - "_\u0000\u0000\u20d6\u20d7\u0003+\u0015\u0000\u20d7\u20d8\u0003!\u0010"+ - "\u0000\u20d8\u20d9\u0003\u0007\u0003\u0000\u20d9\u20da\u0003%\u0012\u0000"+ - "\u20da\u20db\u0003+\u0015\u0000\u20db\u20dc\u0003\u0015\n\u0000\u20dc"+ - "\u20dd\u0003#\u0011\u0000\u20dd\u20de\u0003-\u0016\u0000\u20de\u062a\u0001"+ - "\u0000\u0000\u0000\u20df\u20e0\u0003/\u0017\u0000\u20e0\u20e1\u0003/\u0017"+ - "\u0000\u20e1\u20e2\u0003\u0017\u000b\u0000\u20e2\u20e3\u0003\r\u0006\u0000"+ - "\u20e3\u062c\u0001\u0000\u0000\u0000\u20e4\u20e5\u00031\u0018\u0000\u20e5"+ - "\u20e6\u0003\u0007\u0003\u0000\u20e6\u20e7\u0003)\u0014\u0000\u20e7\u20e8"+ - "\u0003\t\u0004\u0000\u20e8\u20e9\u0003\u0017\u000b\u0000\u20e9\u20ea\u0003"+ - "-\u0016\u0000\u20ea\u062e\u0001\u0000\u0000\u0000\u20eb\u20ec\u00035\u001a"+ - "\u0000\u20ec\u20ed\u0003\u001f\u000f\u0000\u20ed\u20ee\u0003\u001d\u000e"+ - "\u0000\u20ee\u0630\u0001\u0000\u0000\u0000\u20ef\u20f0\u0005,\u0000\u0000"+ - "\u20f0\u0632\u0001\u0000\u0000\u0000\u20f1\u20f2\u0005:\u0000\u0000\u20f2"+ - "\u0634\u0001\u0000\u0000\u0000\u20f3\u20f4\u0005:\u0000\u0000\u20f4\u20f5"+ - "\u0005:\u0000\u0000\u20f5\u0636\u0001\u0000\u0000\u0000\u20f6\u20f7\u0005"+ - "$\u0000\u0000\u20f7\u0638\u0001\u0000\u0000\u0000\u20f8\u20f9\u0005$\u0000"+ - "\u0000\u20f9\u20fa\u0005$\u0000\u0000\u20fa\u063a\u0001\u0000\u0000\u0000"+ - "\u20fb\u20fc\u0005*\u0000\u0000\u20fc\u063c\u0001\u0000\u0000\u0000\u20fd"+ - "\u20fe\u0005(\u0000\u0000\u20fe\u063e\u0001\u0000\u0000\u0000\u20ff\u2100"+ - "\u0005)\u0000\u0000\u2100\u0640\u0001\u0000\u0000\u0000\u2101\u2102\u0005"+ - "[\u0000\u0000\u2102\u0642\u0001\u0000\u0000\u0000\u2103\u2104\u0005]\u0000"+ - "\u0000\u2104\u0644\u0001\u0000\u0000\u0000\u2105\u2106\u0003\t\u0004\u0000"+ - "\u2106\u210a\u0005\'\u0000\u0000\u2107\u2109\u000201\u0000\u2108\u2107"+ - "\u0001\u0000\u0000\u0000\u2109\u210c\u0001\u0000\u0000\u0000\u210a\u2108"+ - "\u0001\u0000\u0000\u0000\u210a\u210b\u0001\u0000\u0000\u0000\u210b\u210d"+ - "\u0001\u0000\u0000\u0000\u210c\u210a\u0001\u0000\u0000\u0000\u210d\u210e"+ - "\u0005\'\u0000\u0000\u210e\u0646\u0001\u0000\u0000\u0000\u210f\u2110\u0003"+ - "\u000f\u0007\u0000\u2110\u2111\u0003A \u0000\u2111\u0648\u0001\u0000\u0000"+ - "\u0000\u2112\u2114\u0005-\u0000\u0000\u2113\u2112\u0001\u0000\u0000\u0000"+ - "\u2113\u2114\u0001\u0000\u0000\u0000\u2114\u2116\u0001\u0000\u0000\u0000"+ - "\u2115\u2117\u0003=\u001e\u0000\u2116\u2115\u0001\u0000\u0000\u0000\u2117"+ - "\u2118\u0001\u0000\u0000\u0000\u2118\u2116\u0001\u0000\u0000\u0000\u2118"+ - "\u2119\u0001\u0000\u0000\u0000\u2119\u211a\u0001\u0000\u0000\u0000\u211a"+ - "\u211c\u0005.\u0000\u0000\u211b\u211d\u0003=\u001e\u0000\u211c\u211b\u0001"+ - "\u0000\u0000\u0000\u211d\u211e\u0001\u0000\u0000\u0000\u211e\u211c\u0001"+ - "\u0000\u0000\u0000\u211e\u211f\u0001\u0000\u0000\u0000\u211f\u212c\u0001"+ - "\u0000\u0000\u0000\u2120\u2124\u0003\u000f\u0007\u0000\u2121\u2123\u0005"+ - "-\u0000\u0000\u2122\u2121\u0001\u0000\u0000\u0000\u2123\u2126\u0001\u0000"+ - "\u0000\u0000\u2124\u2122\u0001\u0000\u0000\u0000\u2124\u2125\u0001\u0000"+ - "\u0000\u0000\u2125\u2128\u0001\u0000\u0000\u0000\u2126\u2124\u0001\u0000"+ - "\u0000\u0000\u2127\u2129\u0003=\u001e\u0000\u2128\u2127\u0001\u0000\u0000"+ - "\u0000\u2129\u212a\u0001\u0000\u0000\u0000\u212a\u2128\u0001\u0000\u0000"+ - "\u0000\u212a\u212b\u0001\u0000\u0000\u0000\u212b\u212d\u0001\u0000\u0000"+ - "\u0000\u212c\u2120\u0001\u0000\u0000\u0000\u212c\u212d\u0001\u0000\u0000"+ - "\u0000\u212d\u064a\u0001\u0000\u0000\u0000\u212e\u2130\u0005-\u0000\u0000"+ - "\u212f\u212e\u0001\u0000\u0000\u0000\u212f\u2130\u0001\u0000\u0000\u0000"+ - "\u2130\u2132\u0001\u0000\u0000\u0000\u2131\u2133\u0003=\u001e\u0000\u2132"+ - "\u2131\u0001\u0000\u0000\u0000\u2133\u2134\u0001\u0000\u0000\u0000\u2134"+ - "\u2132\u0001\u0000\u0000\u0000\u2134\u2135\u0001\u0000\u0000\u0000\u2135"+ - "\u213c\u0001\u0000\u0000\u0000\u2136\u2138\u0003\u000f\u0007\u0000\u2137"+ - "\u2139\u0003=\u001e\u0000\u2138\u2137\u0001\u0000\u0000\u0000\u2139\u213a"+ - "\u0001\u0000\u0000\u0000\u213a\u2138\u0001\u0000\u0000\u0000\u213a\u213b"+ - "\u0001\u0000\u0000\u0000\u213b\u213d\u0001\u0000\u0000\u0000\u213c\u2136"+ - "\u0001\u0000\u0000\u0000\u213c\u213d\u0001\u0000\u0000\u0000\u213d\u064c"+ - "\u0001\u0000\u0000\u0000\u213e\u213f\u0005x\u0000\u0000\u213f\u2140\u0003"+ - "A \u0000\u2140\u064e\u0001\u0000\u0000\u0000\u2141\u2142\u0005.\u0000"+ - "\u0000\u2142\u0650\u0001\u0000\u0000\u0000\u2143\u2144\u0003A \u0000\u2144"+ - "\u0652\u0001\u0000\u0000\u0000\u2145\u2146\u0003?\u001f\u0000\u2146\u0654"+ - "\u0001\u0000\u0000\u0000\u2147\u214b\u0007 \u0000\u0000\u2148\u214a\u0007"+ - "!\u0000\u0000\u2149\u2148\u0001\u0000\u0000\u0000\u214a\u214d\u0001\u0000"+ - "\u0000\u0000\u214b\u2149\u0001\u0000\u0000\u0000\u214b\u214c\u0001\u0000"+ - "\u0000\u0000\u214c\u0656\u0001\u0000\u0000\u0000\u214d\u214b\u0001\u0000"+ - "\u0000\u0000\u214e\u2150\u0005$\u0000\u0000\u214f\u2151\u0003=\u001e\u0000"+ - "\u2150\u214f\u0001\u0000\u0000\u0000\u2151\u2152\u0001\u0000\u0000\u0000"+ - "\u2152\u2150\u0001\u0000\u0000\u0000\u2152\u2153\u0001\u0000\u0000\u0000"+ - "\u2153\u0658\u0001\u0000\u0000\u0000\u2154\u2158\u0007\"\u0000\u0000\u2155"+ - "\u2157\u0007#\u0000\u0000\u2156\u2155\u0001\u0000\u0000\u0000\u2157\u215a"+ - "\u0001\u0000\u0000\u0000\u2158\u2156\u0001\u0000\u0000\u0000\u2158\u2159"+ - "\u0001\u0000\u0000\u0000\u2159\u065a\u0001\u0000\u0000\u0000\u215a\u2158"+ - "\u0001\u0000\u0000\u0000\u215b\u215c\u0005&\u0000\u0000\u215c\u065c\u0001"+ - "\u0000\u0000\u0000\u215d\u215e\u0005&\u0000\u0000\u215e\u215f\u0005&\u0000"+ - "\u0000\u215f\u065e\u0001\u0000\u0000\u0000\u2160\u2161\u0005&\u0000\u0000"+ - "\u2161\u2162\u0005<\u0000\u0000\u2162\u0660\u0001\u0000\u0000\u0000\u2163"+ - "\u2164\u0005@\u0000\u0000\u2164\u2165\u0005@\u0000\u0000\u2165\u0662\u0001"+ - "\u0000\u0000\u0000\u2166\u2167\u0005@\u0000\u0000\u2167\u2168\u0005>\u0000"+ - "\u0000\u2168\u0664\u0001\u0000\u0000\u0000\u2169\u216a\u0005@\u0000\u0000"+ - "\u216a\u0666\u0001\u0000\u0000\u0000\u216b\u216c\u0005!\u0000\u0000\u216c"+ - "\u0668\u0001\u0000\u0000\u0000\u216d\u216e\u0005!\u0000\u0000\u216e\u216f"+ - "\u0005!\u0000\u0000\u216f\u066a\u0001\u0000\u0000\u0000\u2170\u2171\u0005"+ - "!\u0000\u0000\u2171\u2172\u0005=\u0000\u0000\u2172\u066c\u0001\u0000\u0000"+ - "\u0000\u2173\u2174\u0005^\u0000\u0000\u2174\u066e\u0001\u0000\u0000\u0000"+ - "\u2175\u2176\u0005=\u0000\u0000\u2176\u0670\u0001\u0000\u0000\u0000\u2177"+ - "\u2178\u0005=\u0000\u0000\u2178\u2179\u0005>\u0000\u0000\u2179\u0672\u0001"+ - "\u0000\u0000\u0000\u217a\u217b\u0005>\u0000\u0000\u217b\u0674\u0001\u0000"+ - "\u0000\u0000\u217c\u217d\u0005>\u0000\u0000\u217d\u217e\u0005=\u0000\u0000"+ - "\u217e\u0676\u0001\u0000\u0000\u0000\u217f\u2180\u0005>\u0000\u0000\u2180"+ - "\u2181\u0005>\u0000\u0000\u2181\u0678\u0001\u0000\u0000\u0000\u2182\u2183"+ - "\u0005#\u0000\u0000\u2183\u067a\u0001\u0000\u0000\u0000\u2184\u2185\u0005"+ - "#\u0000\u0000\u2185\u2186\u0005=\u0000\u0000\u2186\u067c\u0001\u0000\u0000"+ - "\u0000\u2187\u2188\u0005#\u0000\u0000\u2188\u2189\u0005>\u0000\u0000\u2189"+ - "\u067e\u0001\u0000\u0000\u0000\u218a\u218b\u0005#\u0000\u0000\u218b\u218c"+ - "\u0005>\u0000\u0000\u218c\u218d\u0005>\u0000\u0000\u218d\u0680\u0001\u0000"+ - "\u0000\u0000\u218e\u218f\u0005#\u0000\u0000\u218f\u2190\u0005#\u0000\u0000"+ - "\u2190\u0682\u0001\u0000\u0000\u0000\u2191\u2192\u0005-\u0000\u0000\u2192"+ - "\u2193\u0005>\u0000\u0000\u2193\u0684\u0001\u0000\u0000\u0000\u2194\u2195"+ - "\u0005-\u0000\u0000\u2195\u2196\u0005>\u0000\u0000\u2196\u2197\u0005>"+ - "\u0000\u0000\u2197\u0686\u0001\u0000\u0000\u0000\u2198\u2199\u0005-\u0000"+ - "\u0000\u2199\u219a\u0005|\u0000\u0000\u219a\u219b\u0005-\u0000\u0000\u219b"+ - "\u0688\u0001\u0000\u0000\u0000\u219c\u219d\u0005<\u0000\u0000\u219d\u068a"+ - "\u0001\u0000\u0000\u0000\u219e\u219f\u0005<\u0000\u0000\u219f\u21a0\u0005"+ - "=\u0000\u0000\u21a0\u068c\u0001\u0000\u0000\u0000\u21a1\u21a2\u0005<\u0000"+ - "\u0000\u21a2\u21a3\u0005@\u0000\u0000\u21a3\u068e\u0001\u0000\u0000\u0000"+ - "\u21a4\u21a5\u0005<\u0000\u0000\u21a5\u21a6\u0005^\u0000\u0000\u21a6\u0690"+ - "\u0001\u0000\u0000\u0000\u21a7\u21a8\u0005<\u0000\u0000\u21a8\u21a9\u0005"+ - ">\u0000\u0000\u21a9\u0692\u0001\u0000\u0000\u0000\u21aa\u21ab\u0005<\u0000"+ - "\u0000\u21ab\u21ac\u0005-\u0000\u0000\u21ac\u21ad\u0005>\u0000\u0000\u21ad"+ - "\u0694\u0001\u0000\u0000\u0000\u21ae\u21af\u0005<\u0000\u0000\u21af\u21b0"+ - "\u0005<\u0000\u0000\u21b0\u0696\u0001\u0000\u0000\u0000\u21b1\u21b2\u0005"+ - "<\u0000\u0000\u21b2\u21b3\u0005<\u0000\u0000\u21b3\u21b4\u0005=\u0000"+ - "\u0000\u21b4\u0698\u0001\u0000\u0000\u0000\u21b5\u21b6\u0005<\u0000\u0000"+ - "\u21b6\u21b7\u0005?\u0000\u0000\u21b7\u21b8\u0005>\u0000\u0000\u21b8\u069a"+ - "\u0001\u0000\u0000\u0000\u21b9\u21ba\u0005-\u0000\u0000\u21ba\u069c\u0001"+ - "\u0000\u0000\u0000\u21bb\u21bc\u0005%\u0000\u0000\u21bc\u069e\u0001\u0000"+ - "\u0000\u0000\u21bd\u21be\u0005|\u0000\u0000\u21be\u06a0\u0001\u0000\u0000"+ - "\u0000\u21bf\u21c0\u0005|\u0000\u0000\u21c0\u21c1\u0005|\u0000\u0000\u21c1"+ - "\u06a2\u0001\u0000\u0000\u0000\u21c2\u21c3\u0005|\u0000\u0000\u21c3\u21c4"+ - "\u0005|\u0000\u0000\u21c4\u21c5\u0005/\u0000\u0000\u21c5\u06a4\u0001\u0000"+ - "\u0000\u0000\u21c6\u21c7\u0005|\u0000\u0000\u21c7\u21c8\u0005/\u0000\u0000"+ - "\u21c8\u06a6\u0001\u0000\u0000\u0000\u21c9\u21ca\u0005+\u0000\u0000\u21ca"+ - "\u06a8\u0001\u0000\u0000\u0000\u21cb\u21cc\u0005?\u0000\u0000\u21cc\u06aa"+ - "\u0001\u0000\u0000\u0000\u21cd\u21ce\u0005?\u0000\u0000\u21ce\u21cf\u0005"+ - "&\u0000\u0000\u21cf\u06ac\u0001\u0000\u0000\u0000\u21d0\u21d1\u0005?\u0000"+ - "\u0000\u21d1\u21d2\u0005#\u0000\u0000\u21d2\u06ae\u0001\u0000\u0000\u0000"+ - "\u21d3\u21d4\u0005?\u0000\u0000\u21d4\u21d5\u0005-\u0000\u0000\u21d5\u06b0"+ - "\u0001\u0000\u0000\u0000\u21d6\u21d7\u0005?\u0000\u0000\u21d7\u21d8\u0005"+ - "|\u0000\u0000\u21d8\u06b2\u0001\u0000\u0000\u0000\u21d9\u21da\u0005/\u0000"+ - "\u0000\u21da\u06b4\u0001\u0000\u0000\u0000\u21db\u21dc\u0005~\u0000\u0000"+ - "\u21dc\u06b6\u0001\u0000\u0000\u0000\u21dd\u21de\u0005~\u0000\u0000\u21de"+ - "\u21df\u0005=\u0000\u0000\u21df\u06b8\u0001\u0000\u0000\u0000\u21e0\u21e1"+ - "\u0005~\u0000\u0000\u21e1\u21e2\u0005>\u0000\u0000\u21e2\u21e3\u0005="+ - "\u0000\u0000\u21e3\u21e4\u0005~\u0000\u0000\u21e4\u06ba\u0001\u0000\u0000"+ - "\u0000\u21e5\u21e6\u0005~\u0000\u0000\u21e6\u21e7\u0005>\u0000\u0000\u21e7"+ - "\u21e8\u0005~\u0000\u0000\u21e8\u06bc\u0001\u0000\u0000\u0000\u21e9\u21ea"+ - "\u0005~\u0000\u0000\u21ea\u21eb\u0005<\u0000\u0000\u21eb\u21ec\u0005="+ - "\u0000\u0000\u21ec\u21ed\u0005~\u0000\u0000\u21ed\u06be\u0001\u0000\u0000"+ - "\u0000\u21ee\u21ef\u0005~\u0000\u0000\u21ef\u21f0\u0005<\u0000\u0000\u21f0"+ - "\u21f1\u0005~\u0000\u0000\u21f1\u06c0\u0001\u0000\u0000\u0000\u21f2\u21f3"+ - "\u0005~\u0000\u0000\u21f3\u21f4\u0005*\u0000\u0000\u21f4\u06c2\u0001\u0000"+ - "\u0000\u0000\u21f5\u21f6\u0005~\u0000\u0000\u21f6\u21f7\u0005~\u0000\u0000"+ - "\u21f7\u06c4\u0001\u0000\u0000\u0000\u21f8\u21f9\u0005;\u0000\u0000\u21f9"+ - "\u06c6\u0001\u0000\u0000\u0000\u21fa\u21fb\u0005#\u0000\u0000\u21fb\u21fc"+ - "\u0005{\u0000\u0000\u21fc\u21fd\u0001\u0000\u0000\u0000\u21fd\u21fe\u0003"+ - "\u06c9\u0364\u0000\u21fe\u21ff\u0005}\u0000\u0000\u21ff\u06c8\u0001\u0000"+ - "\u0000\u0000\u2200\u2202\t\u0000\u0000\u0000\u2201\u2200\u0001\u0000\u0000"+ - "\u0000\u2202\u2205\u0001\u0000\u0000\u0000\u2203\u2204\u0001\u0000\u0000"+ - "\u0000\u2203\u2201\u0001\u0000\u0000\u0000\u2204\u06ca\u0001\u0000\u0000"+ - "\u0000\u2205\u2203\u0001\u0000\u0000\u0000\u0019\u0000\u06ce\u06d8\u06e6"+ - "\u072b\u072d\u0738\u073a\u0745\u0747\u210a\u2113\u2118\u211e\u2124\u212a"+ - "\u212c\u212f\u2134\u213a\u213c\u214b\u2152\u2158\u2203\u0002\u0006\u0000"+ - "\u0000\u0000\u0001\u0000"; + "\u0000\u1258\u1259\u0007\u0017\u0000\u0000\u1259\u125a\u0007\n\u0000\u0000"+ + "\u125a\u125b\u0007\u0007\u0000\u0000\u125b\u125c\u0007\n\u0000\u0000\u125c"+ + "\u125d\u0007\r\u0000\u0000\u125d\u125e\u0007\u0005\u0000\u0000\u125e\u125f"+ + "\u0007\u0010\u0000\u0000\u125f\u1260\u0007\n\u0000\u0000\u1260\u1261\u0007"+ + "\f\u0000\u0000\u1261\u037e\u0001\u0000\u0000\u0000\u1262\u1263\u0007\u0006"+ + "\u0000\u0000\u1263\u1264\u0007\u0013\u0000\u0000\u1264\u1265\u0007\u0017"+ + "\u0000\u0000\u1265\u1266\u0007\u0017\u0000\u0000\u1266\u1267\u0007\n\u0000"+ + "\u0000\u1267\u1268\u0007\f\u0000\u0000\u1268\u0380\u0001\u0000\u0000\u0000"+ + "\u1269\u126a\u0007\t\u0000\u0000\u126a\u126b\u0007\u0010\u0000\u0000\u126b"+ + "\u126c\u0007\u0013\u0000\u0000\u126c\u126d\u0007\r\u0000\u0000\u126d\u126e"+ + "\u0007\n\u0000\u0000\u126e\u126f\u0007\f\u0000\u0000\u126f\u0382\u0001"+ + "\u0000\u0000\u0000\u1270\u1271\u0007\u0011\u0000\u0000\u1271\u1272\u0007"+ + "\u0007\u0000\u0000\u1272\u1273\u0007\u000e\u0000\u0000\u1273\u1274\u0007"+ + "\u0006\u0000\u0000\u1274\u1275\u0007\u0016\u0000\u0000\u1275\u1276\u0007"+ + "\f\u0000\u0000\u1276\u1277\u0007\n\u0000\u0000\u1277\u0384\u0001\u0000"+ + "\u0000\u0000\u1278\u1279\u0007\r\u0000\u0000\u1279\u127a\u0007\u0013\u0000"+ + "\u0000\u127a\u127b\u0007\u0016\u0000\u0000\u127b\u127c\u0007\u0010\u0000"+ + "\u0000\u127c\u127d\u0007\u0011\u0000\u0000\u127d\u127e\u0007\u0007\u0000"+ + "\u0000\u127e\u127f\u0007\n\u0000\u0000\u127f\u0386\u0001\u0000\u0000\u0000"+ + "\u1280\u1281\u0007\u0010\u0000\u0000\u1281\u1282\u0007\r\u0000\u0000\u1282"+ + "\u1283\u0007\u0005\u0000\u0000\u1283\u1284\u0007\u0007\u0000\u0000\u1284"+ + "\u1285\u0007\t\u0000\u0000\u1285\u1286\u0007\u0019\u0000\u0000\u1286\u1287"+ + "\u0007\u0013\u0000\u0000\u1287\u1288\u0007\r\u0000\u0000\u1288\u1289\u0007"+ + "\u000f\u0000\u0000\u1289\u0388\u0001\u0000\u0000\u0000\u128a\u128b\u0007"+ + "\u0011\u0000\u0000\u128b\u128c\u0007\u000f\u0000\u0000\u128c\u128d\u0007"+ + "\u0018\u0000\u0000\u128d\u128e\u0007\u0013\u0000\u0000\u128e\u128f\u0007"+ + "\r\u0000\u0000\u128f\u1290\u0007\u0010\u0000\u0000\u1290\u038a\u0001\u0000"+ + "\u0000\u0000\u1291\u1292\u0007\u0018\u0000\u0000\u1292\u1293\u0007\u0013"+ + "\u0000\u0000\u1293\u1294\u0007\u0006\u0000\u0000\u1294\u1295\u0007\u0011"+ + "\u0000\u0000\u1295\u1296\u0007\u000e\u0000\u0000\u1296\u1297\u0007\b\u0000"+ + "\u0000\u1297\u038c\u0001\u0000\u0000\u0000\u1298\u1299\u0007\u000f\u0000"+ + "\u0000\u1299\u129a\u0007\n\u0000\u0000\u129a\u129b\u0007\u0010\u0000\u0000"+ + "\u129b\u129c\u0007\u0014\u0000\u0000\u129c\u129d\u0007\u0013\u0000\u0000"+ + "\u129d\u129e\u0007\f\u0000\u0000\u129e\u038e\u0001\u0000\u0000\u0000\u129f"+ + "\u12a0\u0007\r\u0000\u0000\u12a0\u12a1\u0007\n\u0000\u0000\u12a1\u12a2"+ + "\u0007\u0019\u0000\u0000\u12a2\u12a3\u0007\n\u0000\u0000\u12a3\u12a4\u0007"+ + "\r\u0000\u0000\u12a4\u12a5\u0007\n\u0000\u0000\u12a5\u12a6\u0007\u0007"+ + "\u0000\u0000\u12a6\u12a7\u0007\u000e\u0000\u0000\u12a7\u12a8\u0007\u0011"+ + "\u0000\u0000\u12a8\u12a9\u0007\u0007\u0000\u0000\u12a9\u12aa\u0007\u0017"+ + "\u0000\u0000\u12aa\u0390\u0001\u0000\u0000\u0000\u12ab\u12ac\u0007\u0007"+ + "\u0000\u0000\u12ac\u12ad\u0007\n\u0000\u0000\u12ad\u12ae\u0007\u001d\u0000"+ + "\u0000\u12ae\u0392\u0001\u0000\u0000\u0000\u12af\u12b0\u0007\u0013\u0000"+ + "\u0000\u12b0\u12b1\u0007\u0006\u0000\u0000\u12b1\u12b2\u0007\f\u0000\u0000"+ + "\u12b2\u0394\u0001\u0000\u0000\u0000\u12b3\u12b4\u0007\u001b\u0000\u0000"+ + "\u12b4\u12b5\u0007\u0005\u0000\u0000\u12b5\u12b6\u0007\u0006\u0000\u0000"+ + "\u12b6\u12b7\u0007\u0016\u0000\u0000\u12b7\u12b8\u0007\n\u0000\u0000\u12b8"+ + "\u0396\u0001\u0000\u0000\u0000\u12b9\u12ba\u0007\t\u0000\u0000\u12ba\u12bb"+ + "\u0007\u0016\u0000\u0000\u12bb\u12bc\u0007\u0012\u0000\u0000\u12bc\u12bd"+ + "\u0007\t\u0000\u0000\u12bd\u12be\u0007\u000e\u0000\u0000\u12be\u12bf\u0007"+ + "\r\u0000\u0000\u12bf\u12c0\u0007\u0011\u0000\u0000\u12c0\u12c1\u0007\u0018"+ + "\u0000\u0000\u12c1\u12c2\u0007\u0010\u0000\u0000\u12c2\u12c3\u0007\u0011"+ + "\u0000\u0000\u12c3\u12c4\u0007\u0013\u0000\u0000\u12c4\u12c5\u0007\u0007"+ + "\u0000\u0000\u12c5\u0398\u0001\u0000\u0000\u0000\u12c6\u12c7\u0007\u0018"+ + "\u0000\u0000\u12c7\u12c8\u0007\u0016\u0000\u0000\u12c8\u12c9\u0007\u0012"+ + "\u0000\u0000\u12c9\u12ca\u0007\u0006\u0000\u0000\u12ca\u12cb\u0007\u0011"+ + "\u0000\u0000\u12cb\u12cc\u0007\u000e\u0000\u0000\u12cc\u12cd\u0007\u0005"+ + "\u0000\u0000\u12cd\u12ce\u0007\u0010\u0000\u0000\u12ce\u12cf\u0007\u0011"+ + "\u0000\u0000\u12cf\u12d0\u0007\u0013\u0000\u0000\u12d0\u12d1\u0007\u0007"+ + "\u0000\u0000\u12d1\u039a\u0001\u0000\u0000\u0000\u12d2\u12d3\u0007\u0013"+ + "\u0000\u0000\u12d3\u12d4\u0007\u0016\u0000\u0000\u12d4\u12d5\u0007\u0010"+ + "\u0000\u0000\u12d5\u039c\u0001\u0000\u0000\u0000\u12d6\u12d7\u0007\n\u0000"+ + "\u0000\u12d7\u12d8\u0007\u0007\u0000\u0000\u12d8\u12d9\u0007\f\u0000\u0000"+ + "\u12d9\u039e\u0001\u0000\u0000\u0000\u12da\u12db\u0007\r\u0000\u0000\u12db"+ + "\u12dc\u0007\u0013\u0000\u0000\u12dc\u12dd\u0007\u0016\u0000\u0000\u12dd"+ + "\u12de\u0007\u0010\u0000\u0000\u12de\u12df\u0007\u0011\u0000\u0000\u12df"+ + "\u12e0\u0007\u0007\u0000\u0000\u12e0\u12e1\u0007\n\u0000\u0000\u12e1\u12e2"+ + "\u0007\t\u0000\u0000\u12e2\u03a0\u0001\u0000\u0000\u0000\u12e3\u12e4\u0007"+ + "\t\u0000\u0000\u12e4\u12e5\u0007\u000e\u0000\u0000\u12e5\u12e6\u0007\u0014"+ + "\u0000\u0000\u12e6\u12e7\u0007\n\u0000\u0000\u12e7\u12e8\u0007\u000f\u0000"+ + "\u0000\u12e8\u12e9\u0007\u0005\u0000\u0000\u12e9\u12ea\u0007\t\u0000\u0000"+ + "\u12ea\u03a2\u0001\u0000\u0000\u0000\u12eb\u12ec\u0007\u0018\u0000\u0000"+ + "\u12ec\u12ed\u0007\r\u0000\u0000\u12ed\u12ee\u0007\u0013\u0000\u0000\u12ee"+ + "\u12ef\u0007\u000e\u0000\u0000\u12ef\u12f0\u0007\n\u0000\u0000\u12f0\u12f1"+ + "\u0007\f\u0000\u0000\u12f1\u12f2\u0007\u0016\u0000\u0000\u12f2\u12f3\u0007"+ + "\r\u0000\u0000\u12f3\u12f4\u0007\n\u0000\u0000\u12f4\u12f5\u0007\t\u0000"+ + "\u0000\u12f5\u03a4\u0001\u0000\u0000\u0000\u12f6\u12f7\u0007\u0011\u0000"+ + "\u0000\u12f7\u12f8\u0007\u0007\u0000\u0000\u12f8\u12f9\u0007\u0018\u0000"+ + "\u0000\u12f9\u12fa\u0007\u0016\u0000\u0000\u12fa\u12fb\u0007\u0010\u0000"+ + "\u0000\u12fb\u03a6\u0001\u0000\u0000\u0000\u12fc\u12fd\u0007\t\u0000\u0000"+ + "\u12fd\u12fe\u0007\u0016\u0000\u0000\u12fe\u12ff\u0007\u0018\u0000\u0000"+ + "\u12ff\u1300\u0007\u0018\u0000\u0000\u1300\u1301\u0007\u0013\u0000\u0000"+ + "\u1301\u1302\u0007\r\u0000\u0000\u1302\u1303\u0007\u0010\u0000\u0000\u1303"+ + "\u03a8\u0001\u0000\u0000\u0000\u1304\u1305\u0007\u0018\u0000\u0000\u1305"+ + "\u1306\u0007\u0005\u0000\u0000\u1306\u1307\u0007\r\u0000\u0000\u1307\u1308"+ + "\u0007\u0005\u0000\u0000\u1308\u1309\u0007\u0006\u0000\u0000\u1309\u130a"+ + "\u0007\u0006\u0000\u0000\u130a\u130b\u0007\n\u0000\u0000\u130b\u130c\u0007"+ + "\u0006\u0000\u0000\u130c\u03aa\u0001\u0000\u0000\u0000\u130d\u130e\u0007"+ + "\t\u0000\u0000\u130e\u130f\u0007\u001c\u0000\u0000\u130f\u1310\u0007\u0006"+ + "\u0000\u0000\u1310\u03ac\u0001\u0000\u0000\u0000\u1311\u1312\u0007\f\u0000"+ + "\u0000\u1312\u1313\u0007\n\u0000\u0000\u1313\u1314\u0007\u0018\u0000\u0000"+ + "\u1314\u1315\u0007\n\u0000\u0000\u1315\u1316\u0007\u0007\u0000\u0000\u1316"+ + "\u1317\u0007\f\u0000\u0000\u1317\u1318\u0007\t\u0000\u0000\u1318\u03ae"+ + "\u0001\u0000\u0000\u0000\u1319\u131a\u0007\u0013\u0000\u0000\u131a\u131b"+ + "\u0007\u001b\u0000\u0000\u131b\u131c\u0007\n\u0000\u0000\u131c\u131d\u0007"+ + "\r\u0000\u0000\u131d\u131e\u0007\r\u0000\u0000\u131e\u131f\u0007\u0011"+ + "\u0000\u0000\u131f\u1320\u0007\f\u0000\u0000\u1320\u1321\u0007\u0011\u0000"+ + "\u0000\u1321\u1322\u0007\u0007\u0000\u0000\u1322\u1323\u0007\u0017\u0000"+ + "\u0000\u1323\u03b0\u0001\u0000\u0000\u0000\u1324\u1325\u0007\u000e\u0000"+ + "\u0000\u1325\u1326\u0007\u0013\u0000\u0000\u1326\u1327\u0007\u0007\u0000"+ + "\u0000\u1327\u1328\u0007\u0019\u0000\u0000\u1328\u1329\u0007\u0006\u0000"+ + "\u0000\u1329\u132a\u0007\u0011\u0000\u0000\u132a\u132b\u0007\u000e\u0000"+ + "\u0000\u132b\u132c\u0007\u0010\u0000\u0000\u132c\u03b2\u0001\u0000\u0000"+ + "\u0000\u132d\u132e\u0007\t\u0000\u0000\u132e\u132f\u0007\u0015\u0000\u0000"+ + "\u132f\u1330\u0007\u0011\u0000\u0000\u1330\u1331\u0007\u0018\u0000\u0000"+ + "\u1331\u03b4\u0001\u0000\u0000\u0000\u1332\u1333\u0007\u0006\u0000\u0000"+ + "\u1333\u1334\u0007\u0013\u0000\u0000\u1334\u1335\u0007\u000e\u0000\u0000"+ + "\u1335\u1336\u0007\u0015\u0000\u0000\u1336\u1337\u0007\n\u0000\u0000\u1337"+ + "\u1338\u0007\f\u0000\u0000\u1338\u03b6\u0001\u0000\u0000\u0000\u1339\u133a"+ + "\u0007\u0010\u0000\u0000\u133a\u133b\u0007\u0011\u0000\u0000\u133b\u133c"+ + "\u0007\n\u0000\u0000\u133c\u133d\u0007\t\u0000\u0000\u133d\u03b8\u0001"+ + "\u0000\u0000\u0000\u133e\u133f\u0007\r\u0000\u0000\u133f\u1340\u0007\u0013"+ + "\u0000\u0000\u1340\u1341\u0007\u0006\u0000\u0000\u1341\u1342\u0007\u0006"+ + "\u0000\u0000\u1342\u1343\u0007\u0016\u0000\u0000\u1343\u1344\u0007\u0018"+ + "\u0000\u0000\u1344\u03ba\u0001\u0000\u0000\u0000\u1345\u1346\u0007\u000e"+ + "\u0000\u0000\u1346\u1347\u0007\u0016\u0000\u0000\u1347\u1348\u0007\u0012"+ + "\u0000\u0000\u1348\u1349\u0007\n\u0000\u0000\u1349\u03bc\u0001\u0000\u0000"+ + "\u0000\u134a\u134b\u0007\u0017\u0000\u0000\u134b\u134c\u0007\r\u0000\u0000"+ + "\u134c\u134d\u0007\u0013\u0000\u0000\u134d\u134e\u0007\u0016\u0000\u0000"+ + "\u134e\u134f\u0007\u0018\u0000\u0000\u134f\u1350\u0007\u0011\u0000\u0000"+ + "\u1350\u1351\u0007\u0007\u0000\u0000\u1351\u1352\u0007\u0017\u0000\u0000"+ + "\u1352\u03be\u0001\u0000\u0000\u0000\u1353\u1354\u0007\t\u0000\u0000\u1354"+ + "\u1355\u0007\n\u0000\u0000\u1355\u1356\u0007\u0010\u0000\u0000\u1356\u1357"+ + "\u0007\t\u0000\u0000\u1357\u03c0\u0001\u0000\u0000\u0000\u1358\u1359\u0007"+ + "\u0010\u0000\u0000\u1359\u135a\u0007\u0005\u0000\u0000\u135a\u135b\u0007"+ + "\u0012\u0000\u0000\u135b\u135c\u0007\u0006\u0000\u0000\u135c\u135d\u0007"+ + "\n\u0000\u0000\u135d\u135e\u0007\t\u0000\u0000\u135e\u135f\u0007\u0005"+ + "\u0000\u0000\u135f\u1360\u0007\u000f\u0000\u0000\u1360\u1361\u0007\u0018"+ + "\u0000\u0000\u1361\u1362\u0007\u0006\u0000\u0000\u1362\u1363\u0007\n\u0000"+ + "\u0000\u1363\u03c2\u0001\u0000\u0000\u0000\u1364\u1365\u0007\u0013\u0000"+ + "\u0000\u1365\u1366\u0007\r\u0000\u0000\u1366\u1367\u0007\f\u0000\u0000"+ + "\u1367\u1368\u0007\u0011\u0000\u0000\u1368\u1369\u0007\u0007\u0000\u0000"+ + "\u1369\u136a\u0007\u0005\u0000\u0000\u136a\u136b\u0007\u0006\u0000\u0000"+ + "\u136b\u136c\u0007\u0011\u0000\u0000\u136c\u136d\u0007\u0010\u0000\u0000"+ + "\u136d\u136e\u0007\b\u0000\u0000\u136e\u03c4\u0001\u0000\u0000\u0000\u136f"+ + "\u1370\u0007\u001a\u0000\u0000\u1370\u1371\u0007\u000f\u0000\u0000\u1371"+ + "\u1372\u0007\u0006\u0000\u0000\u1372\u1373\u0007\u0010\u0000\u0000\u1373"+ + "\u1374\u0007\u0005\u0000\u0000\u1374\u1375\u0007\u0012\u0000\u0000\u1375"+ + "\u1376\u0007\u0006\u0000\u0000\u1376\u1377\u0007\n\u0000\u0000\u1377\u03c6"+ + "\u0001\u0000\u0000\u0000\u1378\u1379\u0007\u000e\u0000\u0000\u1379\u137a"+ + "\u0007\u0013\u0000\u0000\u137a\u137b\u0007\u0006\u0000\u0000\u137b\u137c"+ + "\u0007\u0016\u0000\u0000\u137c\u137d\u0007\u000f\u0000\u0000\u137d\u137e"+ + "\u0007\u0007\u0000\u0000\u137e\u137f\u0007\t\u0000\u0000\u137f\u03c8\u0001"+ + "\u0000\u0000\u0000\u1380\u1381\u0007\u001a\u0000\u0000\u1381\u1382\u0007"+ + "\u000f\u0000\u0000\u1382\u1383\u0007\u0006\u0000\u0000\u1383\u1384\u0007"+ + "\u0007\u0000\u0000\u1384\u1385\u0007\u0005\u0000\u0000\u1385\u1386\u0007"+ + "\u000f\u0000\u0000\u1386\u1387\u0007\n\u0000\u0000\u1387\u1388\u0007\t"+ + "\u0000\u0000\u1388\u1389\u0007\u0018\u0000\u0000\u1389\u138a\u0007\u0005"+ + "\u0000\u0000\u138a\u138b\u0007\u000e\u0000\u0000\u138b\u138c\u0007\n\u0000"+ + "\u0000\u138c\u138d\u0007\t\u0000\u0000\u138d\u03ca\u0001\u0000\u0000\u0000"+ + "\u138e\u138f\u0007\r\u0000\u0000\u138f\u1390\u0007\u0013\u0000\u0000\u1390"+ + "\u1391\u0007\u001d\u0000\u0000\u1391\u1392\u0007\u0010\u0000\u0000\u1392"+ + "\u1393\u0007\b\u0000\u0000\u1393\u1394\u0007\u0018\u0000\u0000\u1394\u1395"+ + "\u0007\n\u0000\u0000\u1395\u03cc\u0001\u0000\u0000\u0000\u1396\u1397\u0007"+ + "\u0007\u0000\u0000\u1397\u1398\u0007\u0013\u0000\u0000\u1398\u1399\u0007"+ + "\r\u0000\u0000\u1399\u139a\u0007\u000f\u0000\u0000\u139a\u139b\u0007\u0005"+ + "\u0000\u0000\u139b\u139c\u0007\u0006\u0000\u0000\u139c\u139d\u0007\u0011"+ + "\u0000\u0000\u139d\u139e\u0007\u000b\u0000\u0000\u139e\u139f\u0007\n\u0000"+ + "\u0000\u139f\u13a0\u0007\f\u0000\u0000\u13a0\u03ce\u0001\u0000\u0000\u0000"+ + "\u13a1\u13a2\u0007\u001d\u0000\u0000\u13a2\u13a3\u0007\u0011\u0000\u0000"+ + "\u13a3\u13a4\u0007\u0010\u0000\u0000\u13a4\u13a5\u0007\u0014\u0000\u0000"+ + "\u13a5\u13a6\u0007\u0011\u0000\u0000\u13a6\u13a7\u0007\u0007\u0000\u0000"+ + "\u13a7\u03d0\u0001\u0000\u0000\u0000\u13a8\u13a9\u0007\u0019\u0000\u0000"+ + "\u13a9\u13aa\u0007\u0011\u0000\u0000\u13aa\u13ab\u0007\u0006\u0000\u0000"+ + "\u13ab\u13ac\u0007\u0010\u0000\u0000\u13ac\u13ad\u0007\n\u0000\u0000\u13ad"+ + "\u13ae\u0007\r\u0000\u0000\u13ae\u03d2\u0001\u0000\u0000\u0000\u13af\u13b0"+ + "\u0007\u0017\u0000\u0000\u13b0\u13b1\u0007\r\u0000\u0000\u13b1\u13b2\u0007"+ + "\u0013\u0000\u0000\u13b2\u13b3\u0007\u0016\u0000\u0000\u13b3\u13b4\u0007"+ + "\u0018\u0000\u0000\u13b4\u13b5\u0007\t\u0000\u0000\u13b5\u03d4\u0001\u0000"+ + "\u0000\u0000\u13b6\u13b7\u0007\u0013\u0000\u0000\u13b7\u13b8\u0007\u0010"+ + "\u0000\u0000\u13b8\u13b9\u0007\u0014\u0000\u0000\u13b9\u13ba\u0007\n\u0000"+ + "\u0000\u13ba\u13bb\u0007\r\u0000\u0000\u13bb\u13bc\u0007\t\u0000\u0000"+ + "\u13bc\u03d6\u0001\u0000\u0000\u0000\u13bd\u13be\u0007\u0007\u0000\u0000"+ + "\u13be\u13bf\u0007\u0019\u0000\u0000\u13bf\u13c0\u0007\u000e\u0000\u0000"+ + "\u13c0\u03d8\u0001\u0000\u0000\u0000\u13c1\u13c2\u0007\u0007\u0000\u0000"+ + "\u13c2\u13c3\u0007\u0019\u0000\u0000\u13c3\u13c4\u0007\f\u0000\u0000\u13c4"+ + "\u03da\u0001\u0000\u0000\u0000\u13c5\u13c6\u0007\u0007\u0000\u0000\u13c6"+ + "\u13c7\u0007\u0019\u0000\u0000\u13c7\u13c8\u0007\u0015\u0000\u0000\u13c8"+ + "\u13c9\u0007\u000e\u0000\u0000\u13c9\u03dc\u0001\u0000\u0000\u0000\u13ca"+ + "\u13cb\u0007\u0007\u0000\u0000\u13cb\u13cc\u0007\u0019\u0000\u0000\u13cc"+ + "\u13cd\u0007\u0015\u0000\u0000\u13cd\u13ce\u0007\f\u0000\u0000\u13ce\u03de"+ + "\u0001\u0000\u0000\u0000\u13cf\u13d0\u0007\u0016\u0000\u0000\u13d0\u13d1"+ + "\u0007\n\u0000\u0000\u13d1\u13d2\u0007\t\u0000\u0000\u13d2\u13d3\u0007"+ + "\u000e\u0000\u0000\u13d3\u13d4\u0007\u0005\u0000\u0000\u13d4\u13d5\u0007"+ + "\u0018\u0000\u0000\u13d5\u13d6\u0007\n\u0000\u0000\u13d6\u03e0\u0001\u0000"+ + "\u0000\u0000\u13d7\u13d8\u0007\u001b\u0000\u0000\u13d8\u13d9\u0007\u0011"+ + "\u0000\u0000\u13d9\u13da\u0007\n\u0000\u0000\u13da\u13db\u0007\u001d\u0000"+ + "\u0000\u13db\u13dc\u0007\t\u0000\u0000\u13dc\u03e2\u0001\u0000\u0000\u0000"+ + "\u13dd\u13de\u0007\u0007\u0000\u0000\u13de\u13df\u0007\u0013\u0000\u0000"+ + "\u13df\u13e0\u0007\r\u0000\u0000\u13e0\u13e1\u0007\u000f\u0000\u0000\u13e1"+ + "\u13e2\u0007\u0005\u0000\u0000\u13e2\u13e3\u0007\u0006\u0000\u0000\u13e3"+ + "\u13e4\u0007\u0011\u0000\u0000\u13e4\u13e5\u0007\u000b\u0000\u0000\u13e5"+ + "\u13e6\u0007\n\u0000\u0000\u13e6\u03e4\u0001\u0000\u0000\u0000\u13e7\u13e8"+ + "\u0007\f\u0000\u0000\u13e8\u13e9\u0007\u0016\u0000\u0000\u13e9\u13ea\u0007"+ + "\u000f\u0000\u0000\u13ea\u13eb\u0007\u0018\u0000\u0000\u13eb\u03e6\u0001"+ + "\u0000\u0000\u0000\u13ec\u13ed\u0007\u0018\u0000\u0000\u13ed\u13ee\u0007"+ + "\r\u0000\u0000\u13ee\u13ef\u0007\u0011\u0000\u0000\u13ef\u13f0\u0007\u0007"+ + "\u0000\u0000\u13f0\u13f1\u0007\u0010\u0000\u0000\u13f1\u13f2\u0005_\u0000"+ + "\u0000\u13f2\u13f3\u0007\t\u0000\u0000\u13f3\u13f4\u0007\u0010\u0000\u0000"+ + "\u13f4\u13f5\u0007\r\u0000\u0000\u13f5\u13f6\u0007\u0011\u0000\u0000\u13f6"+ + "\u13f7\u0007\u000e\u0000\u0000\u13f7\u13f8\u0007\u0010\u0000\u0000\u13f8"+ + "\u13f9\u0005_\u0000\u0000\u13f9\u13fa\u0007\u0018\u0000\u0000\u13fa\u13fb"+ + "\u0007\u0005\u0000\u0000\u13fb\u13fc\u0007\r\u0000\u0000\u13fc\u13fd\u0007"+ + "\u0005\u0000\u0000\u13fd\u13fe\u0007\u000f\u0000\u0000\u13fe\u13ff\u0007"+ + "\t\u0000\u0000\u13ff\u03e8\u0001\u0000\u0000\u0000\u1400\u1401\u0007\u001b"+ + "\u0000\u0000\u1401\u1402\u0007\u0005\u0000\u0000\u1402\u1403\u0007\r\u0000"+ + "\u0000\u1403\u1404\u0007\u0011\u0000\u0000\u1404\u1405\u0007\u0005\u0000"+ + "\u0000\u1405\u1406\u0007\u0012\u0000\u0000\u1406\u1407\u0007\u0006\u0000"+ + "\u0000\u1407\u1408\u0007\n\u0000\u0000\u1408\u1409\u0005_\u0000\u0000"+ + "\u1409\u140a\u0007\u000e\u0000\u0000\u140a\u140b\u0007\u0013\u0000\u0000"+ + "\u140b\u140c\u0007\u0007\u0000\u0000\u140c\u140d\u0007\u0019\u0000\u0000"+ + "\u140d\u140e\u0007\u0006\u0000\u0000\u140e\u140f\u0007\u0011\u0000\u0000"+ + "\u140f\u1410\u0007\u000e\u0000\u0000\u1410\u1411\u0007\u0010\u0000\u0000"+ + "\u1411\u03ea\u0001\u0000\u0000\u0000\u1412\u1413\u0007\n\u0000\u0000\u1413"+ + "\u1414\u0007\r\u0000\u0000\u1414\u1415\u0007\r\u0000\u0000\u1415\u1416"+ + "\u0007\u0013\u0000\u0000\u1416\u1417\u0007\r\u0000\u0000\u1417\u03ec\u0001"+ + "\u0000\u0000\u0000\u1418\u1419\u0007\u0016\u0000\u0000\u1419\u141a\u0007"+ + "\t\u0000\u0000\u141a\u141b\u0007\n\u0000\u0000\u141b\u141c\u0005_\u0000"+ + "\u0000\u141c\u141d\u0007\u001b\u0000\u0000\u141d\u141e\u0007\u0005\u0000"+ + "\u0000\u141e\u141f\u0007\r\u0000\u0000\u141f\u1420\u0007\u0011\u0000\u0000"+ + "\u1420\u1421\u0007\u0005\u0000\u0000\u1421\u1422\u0007\u0012\u0000\u0000"+ + "\u1422\u1423\u0007\u0006\u0000\u0000\u1423\u1424\u0007\n\u0000\u0000\u1424"+ + "\u03ee\u0001\u0000\u0000\u0000\u1425\u1426\u0007\u0016\u0000\u0000\u1426"+ + "\u1427\u0007\t\u0000\u0000\u1427\u1428\u0007\n\u0000\u0000\u1428\u1429"+ + "\u0005_\u0000\u0000\u1429\u142a\u0007\u000e\u0000\u0000\u142a\u142b\u0007"+ + "\u0013\u0000\u0000\u142b\u142c\u0007\u0006\u0000\u0000\u142c\u142d\u0007"+ + "\u0016\u0000\u0000\u142d\u142e\u0007\u000f\u0000\u0000\u142e\u142f\u0007"+ + "\u0007\u0000\u0000\u142f\u03f0\u0001\u0000\u0000\u0000\u1430\u1431\u0007"+ + "\u0005\u0000\u0000\u1431\u1432\u0007\u0006\u0000\u0000\u1432\u1433\u0007"+ + "\u0011\u0000\u0000\u1433\u1434\u0007\u0005\u0000\u0000\u1434\u1435\u0007"+ + "\t\u0000\u0000\u1435\u03f2\u0001\u0000\u0000\u0000\u1436\u1437\u0007\u000e"+ + "\u0000\u0000\u1437\u1438\u0007\u0013\u0000\u0000\u1438\u1439\u0007\u0007"+ + "\u0000\u0000\u1439\u143a\u0007\t\u0000\u0000\u143a\u143b\u0007\u0010\u0000"+ + "\u0000\u143b\u143c\u0007\u0005\u0000\u0000\u143c\u143d\u0007\u0007\u0000"+ + "\u0000\u143d\u143e\u0007\u0010\u0000\u0000\u143e\u03f4\u0001\u0000\u0000"+ + "\u0000\u143f\u1440\u0007\u0018\u0000\u0000\u1440\u1441\u0007\n\u0000\u0000"+ + "\u1441\u1442\u0007\r\u0000\u0000\u1442\u1443\u0007\u0019\u0000\u0000\u1443"+ + "\u1444\u0007\u0013\u0000\u0000\u1444\u1445\u0007\r\u0000\u0000\u1445\u1446"+ + "\u0007\u000f\u0000\u0000\u1446\u03f6\u0001\u0000\u0000\u0000\u1447\u1448"+ + "\u0007\u0017\u0000\u0000\u1448\u1449\u0007\n\u0000\u0000\u1449\u144a\u0007"+ + "\u0010\u0000\u0000\u144a\u03f8\u0001\u0000\u0000\u0000\u144b\u144c\u0007"+ + "\f\u0000\u0000\u144c\u144d\u0007\u0011\u0000\u0000\u144d\u144e\u0007\u0005"+ + "\u0000\u0000\u144e\u144f\u0007\u0017\u0000\u0000\u144f\u1450\u0007\u0007"+ + "\u0000\u0000\u1450\u1451\u0007\u0013\u0000\u0000\u1451\u1452\u0007\t\u0000"+ + "\u0000\u1452\u1453\u0007\u0010\u0000\u0000\u1453\u1454\u0007\u0011\u0000"+ + "\u0000\u1454\u1455\u0007\u000e\u0000\u0000\u1455\u1456\u0007\t\u0000\u0000"+ + "\u1456\u03fa\u0001\u0000\u0000\u0000\u1457\u1458\u0007\t\u0000\u0000\u1458"+ + "\u1459\u0007\u0010\u0000\u0000\u1459\u145a\u0007\u0005\u0000\u0000\u145a"+ + "\u145b\u0007\u000e\u0000\u0000\u145b\u145c\u0007\u0015\u0000\u0000\u145c"+ + "\u145d\u0007\n\u0000\u0000\u145d\u145e\u0007\f\u0000\u0000\u145e\u03fc"+ + "\u0001\u0000\u0000\u0000\u145f\u1460\u0007\n\u0000\u0000\u1460\u1461\u0007"+ + "\u0006\u0000\u0000\u1461\u1462\u0007\t\u0000\u0000\u1462\u1463\u0007\u0011"+ + "\u0000\u0000\u1463\u1464\u0007\u0019\u0000\u0000\u1464\u03fe\u0001\u0000"+ + "\u0000\u0000\u1465\u1466\u0007\u001d\u0000\u0000\u1466\u1467\u0007\u0014"+ + "\u0000\u0000\u1467\u1468\u0007\u0011\u0000\u0000\u1468\u1469\u0007\u0006"+ + "\u0000\u0000\u1469\u146a\u0007\n\u0000\u0000\u146a\u0400\u0001\u0000\u0000"+ + "\u0000\u146b\u146c\u0007\r\u0000\u0000\u146c\u146d\u0007\n\u0000\u0000"+ + "\u146d\u146e\u0007\u001b\u0000\u0000\u146e\u146f\u0007\n\u0000\u0000\u146f"+ + "\u1470\u0007\r\u0000\u0000\u1470\u1471\u0007\t\u0000\u0000\u1471\u1472"+ + "\u0007\n\u0000\u0000\u1472\u0402\u0001\u0000\u0000\u0000\u1473\u1474\u0007"+ + "\u0019\u0000\u0000\u1474\u1475\u0007\u0013\u0000\u0000\u1475\u1476\u0007"+ + "\r\u0000\u0000\u1476\u1477\u0007\n\u0000\u0000\u1477\u1478\u0007\u0005"+ + "\u0000\u0000\u1478\u1479\u0007\u000e\u0000\u0000\u1479\u147a\u0007\u0014"+ + "\u0000\u0000\u147a\u0404\u0001\u0000\u0000\u0000\u147b\u147c\u0007\t\u0000"+ + "\u0000\u147c\u147d\u0007\u0006\u0000\u0000\u147d\u147e\u0007\u0011\u0000"+ + "\u0000\u147e\u147f\u0007\u000e\u0000\u0000\u147f\u1480\u0007\n\u0000\u0000"+ + "\u1480\u0406\u0001\u0000\u0000\u0000\u1481\u1482\u0007\n\u0000\u0000\u1482"+ + "\u1483\u0007\u001a\u0000\u0000\u1483\u1484\u0007\u0011\u0000\u0000\u1484"+ + "\u1485\u0007\u0010\u0000\u0000\u1485\u0408\u0001\u0000\u0000\u0000\u1486"+ + "\u1487\u0007\r\u0000\u0000\u1487\u1488\u0007\n\u0000\u0000\u1488\u1489"+ + "\u0007\u0010\u0000\u0000\u1489\u148a\u0007\u0016\u0000\u0000\u148a\u148b"+ + "\u0007\r\u0000\u0000\u148b\u148c\u0007\u0007\u0000\u0000\u148c\u040a\u0001"+ + "\u0000\u0000\u0000\u148d\u148e\u0007\u001c\u0000\u0000\u148e\u148f\u0007"+ + "\u0016\u0000\u0000\u148f\u1490\u0007\n\u0000\u0000\u1490\u1491\u0007\r"+ + "\u0000\u0000\u1491\u1492\u0007\b\u0000\u0000\u1492\u040c\u0001\u0000\u0000"+ + "\u0000\u1493\u1494\u0007\r\u0000\u0000\u1494\u1495\u0007\u0005\u0000\u0000"+ + "\u1495\u1496\u0007\u0011\u0000\u0000\u1496\u1497\u0007\t\u0000\u0000\u1497"+ + "\u1498\u0007\n\u0000\u0000\u1498\u040e\u0001\u0000\u0000\u0000\u1499\u149a"+ + "\u0007\t\u0000\u0000\u149a\u149b\u0007\u001c\u0000\u0000\u149b\u149c\u0007"+ + "\u0006\u0000\u0000\u149c\u149d\u0007\t\u0000\u0000\u149d\u149e\u0007\u0010"+ + "\u0000\u0000\u149e\u149f\u0007\u0005\u0000\u0000\u149f\u14a0\u0007\u0010"+ + "\u0000\u0000\u14a0\u14a1\u0007\n\u0000\u0000\u14a1\u0410\u0001\u0000\u0000"+ + "\u0000\u14a2\u14a3\u0007\f\u0000\u0000\u14a3\u14a4\u0007\n\u0000\u0000"+ + "\u14a4\u14a5\u0007\u0012\u0000\u0000\u14a5\u14a6\u0007\u0016\u0000\u0000"+ + "\u14a6\u14a7\u0007\u0017\u0000\u0000\u14a7\u0412\u0001\u0000\u0000\u0000"+ + "\u14a8\u14a9\u0007\u0006\u0000\u0000\u14a9\u14aa\u0007\u0013\u0000\u0000"+ + "\u14aa\u14ab\u0007\u0017\u0000\u0000\u14ab\u0414\u0001\u0000\u0000\u0000"+ + "\u14ac\u14ad\u0007\u0011\u0000\u0000\u14ad\u14ae\u0007\u0007\u0000\u0000"+ + "\u14ae\u14af\u0007\u0019\u0000\u0000\u14af\u14b0\u0007\u0013\u0000\u0000"+ + "\u14b0\u0416\u0001\u0000\u0000\u0000\u14b1\u14b2\u0007\u0007\u0000\u0000"+ + "\u14b2\u14b3\u0007\u0013\u0000\u0000\u14b3\u14b4\u0007\u0010\u0000\u0000"+ + "\u14b4\u14b5\u0007\u0011\u0000\u0000\u14b5\u14b6\u0007\u000e\u0000\u0000"+ + "\u14b6\u14b7\u0007\n\u0000\u0000\u14b7\u0418\u0001\u0000\u0000\u0000\u14b8"+ + "\u14b9\u0007\u001d\u0000\u0000\u14b9\u14ba\u0007\u0005\u0000\u0000\u14ba"+ + "\u14bb\u0007\r\u0000\u0000\u14bb\u14bc\u0007\u0007\u0000\u0000\u14bc\u14bd"+ + "\u0007\u0011\u0000\u0000\u14bd\u14be\u0007\u0007\u0000\u0000\u14be\u14bf"+ + "\u0007\u0017\u0000\u0000\u14bf\u041a\u0001\u0000\u0000\u0000\u14c0\u14c1"+ + "\u0007\n\u0000\u0000\u14c1\u14c2\u0007\u001a\u0000\u0000\u14c2\u14c3\u0007"+ + "\u000e\u0000\u0000\u14c3\u14c4\u0007\n\u0000\u0000\u14c4\u14c5\u0007\u0018"+ + "\u0000\u0000\u14c5\u14c6\u0007\u0010\u0000\u0000\u14c6\u14c7\u0007\u0011"+ + "\u0000\u0000\u14c7\u14c8\u0007\u0013\u0000\u0000\u14c8\u14c9\u0007\u0007"+ + "\u0000\u0000\u14c9\u041c\u0001\u0000\u0000\u0000\u14ca\u14cb\u0007\u0005"+ + "\u0000\u0000\u14cb\u14cc\u0007\t\u0000\u0000\u14cc\u14cd\u0007\t\u0000"+ + "\u0000\u14cd\u14ce\u0007\n\u0000\u0000\u14ce\u14cf\u0007\r\u0000\u0000"+ + "\u14cf\u14d0\u0007\u0010\u0000\u0000\u14d0\u041e\u0001\u0000\u0000\u0000"+ + "\u14d1\u14d2\u0007\u0006\u0000\u0000\u14d2\u14d3\u0007\u0013\u0000\u0000"+ + "\u14d3\u14d4\u0007\u0013\u0000\u0000\u14d4\u14d5\u0007\u0018\u0000\u0000"+ + "\u14d5\u0420\u0001\u0000\u0000\u0000\u14d6\u14d7\u0007\u0013\u0000\u0000"+ + "\u14d7\u14d8\u0007\u0018\u0000\u0000\u14d8\u14d9\u0007\n\u0000\u0000\u14d9"+ + "\u14da\u0007\u0007\u0000\u0000\u14da\u0422\u0001\u0000\u0000\u0000\u14db"+ + "\u14dc\u0007\u0010\u0000\u0000\u14dc\u14dd\u0007\u0013\u0000\u0000\u14dd"+ + "\u14de\u0007\u0018\u0000\u0000\u14de\u0424\u0001\u0000\u0000\u0000\u14df"+ + "\u14e0\u0007\u0005\u0000\u0000\u14e0\u14e1\u0007\u0012\u0000\u0000\u14e1"+ + "\u14e2\u0007\t\u0000\u0000\u14e2\u0426\u0001\u0000\u0000\u0000\u14e3\u14e4"+ + "\u0007\u000e\u0000\u0000\u14e4\u14e5\u0007\u0012\u0000\u0000\u14e5\u14e6"+ + "\u0007\r\u0000\u0000\u14e6\u14e7\u0007\u0010\u0000\u0000\u14e7\u0428\u0001"+ + "\u0000\u0000\u0000\u14e8\u14e9\u0007\u000e\u0000\u0000\u14e9\u14ea\u0007"+ + "\n\u0000\u0000\u14ea\u14eb\u0007\u0011\u0000\u0000\u14eb\u14ec\u0007\u0006"+ + "\u0000\u0000\u14ec\u042a\u0001\u0000\u0000\u0000\u14ed\u14ee\u0007\u000e"+ + "\u0000\u0000\u14ee\u14ef\u0007\n\u0000\u0000\u14ef\u14f0\u0007\u0011\u0000"+ + "\u0000\u14f0\u14f1\u0007\u0006\u0000\u0000\u14f1\u14f2\u0007\u0011\u0000"+ + "\u0000\u14f2\u14f3\u0007\u0007\u0000\u0000\u14f3\u14f4\u0007\u0017\u0000"+ + "\u0000\u14f4\u042c\u0001\u0000\u0000\u0000\u14f5\u14f6\u0007\f\u0000\u0000"+ + "\u14f6\u14f7\u0007\n\u0000\u0000\u14f7\u14f8\u0007\u0017\u0000\u0000\u14f8"+ + "\u14f9\u0007\r\u0000\u0000\u14f9\u14fa\u0007\n\u0000\u0000\u14fa\u14fb"+ + "\u0007\n\u0000\u0000\u14fb\u14fc\u0007\t\u0000\u0000\u14fc\u042e\u0001"+ + "\u0000\u0000\u0000\u14fd\u14fe\u0007\f\u0000\u0000\u14fe\u14ff\u0007\u0011"+ + "\u0000\u0000\u14ff\u1500\u0007\u001b\u0000\u0000\u1500\u0430\u0001\u0000"+ + "\u0000\u0000\u1501\u1502\u0007\n\u0000\u0000\u1502\u1503\u0007\u001a\u0000"+ + "\u0000\u1503\u1504\u0007\u0018\u0000\u0000\u1504\u0432\u0001\u0000\u0000"+ + "\u0000\u1505\u1506\u0007\u0019\u0000\u0000\u1506\u1507\u0007\u0005\u0000"+ + "\u0000\u1507\u1508\u0007\u000e\u0000\u0000\u1508\u1509\u0007\u0010\u0000"+ + "\u0000\u1509\u150a\u0007\u0013\u0000\u0000\u150a\u150b\u0007\r\u0000\u0000"+ + "\u150b\u150c\u0007\u0011\u0000\u0000\u150c\u150d\u0007\u0005\u0000\u0000"+ + "\u150d\u150e\u0007\u0006\u0000\u0000\u150e\u0434\u0001\u0000\u0000\u0000"+ + "\u150f\u1510\u0007\u0019\u0000\u0000\u1510\u1511\u0007\u0006\u0000\u0000"+ + "\u1511\u1512\u0007\u0013\u0000\u0000\u1512\u1513\u0007\u0013\u0000\u0000"+ + "\u1513\u1514\u0007\r\u0000\u0000\u1514\u0436\u0001\u0000\u0000\u0000\u1515"+ + "\u1516\u0007\u0017\u0000\u0000\u1516\u1517\u0007\u000e\u0000\u0000\u1517"+ + "\u1518\u0007\f\u0000\u0000\u1518\u0438\u0001\u0000\u0000\u0000\u1519\u151a"+ + "\u0007\u0006\u0000\u0000\u151a\u151b\u0007\u000e\u0000\u0000\u151b\u151c"+ + "\u0007\u000f\u0000\u0000\u151c\u043a\u0001\u0000\u0000\u0000\u151d\u151e"+ + "\u0007\u0006\u0000\u0000\u151e\u151f\u0007\u0007\u0000\u0000\u151f\u043c"+ + "\u0001\u0000\u0000\u0000\u1520\u1521\u0007\u0006\u0000\u0000\u1521\u1522"+ + "\u0007\u0013\u0000\u0000\u1522\u1523\u0007\u0017\u0000\u0000\u1523\u1524"+ + "\u00051\u0000\u0000\u1524\u1525\u00050\u0000\u0000\u1525\u043e\u0001\u0000"+ + "\u0000\u0000\u1526\u1527\u0007\u000f\u0000\u0000\u1527\u1528\u0007\u0011"+ + "\u0000\u0000\u1528\u1529\u0007\u0007\u0000\u0000\u1529\u152a\u0005_\u0000"+ + "\u0000\u152a\u152b\u0007\t\u0000\u0000\u152b\u152c\u0007\u000e\u0000\u0000"+ + "\u152c\u152d\u0007\u0005\u0000\u0000\u152d\u152e\u0007\u0006\u0000\u0000"+ + "\u152e\u152f\u0007\n\u0000\u0000\u152f\u0440\u0001\u0000\u0000\u0000\u1530"+ + "\u1531\u0007\u000f\u0000\u0000\u1531\u1532\u0007\u0013\u0000\u0000\u1532"+ + "\u1533\u0007\f\u0000\u0000\u1533\u0442\u0001\u0000\u0000\u0000\u1534\u1535"+ + "\u0007\u0018\u0000\u0000\u1535\u1536\u0007\u0011\u0000\u0000\u1536\u0444"+ + "\u0001\u0000\u0000\u0000\u1537\u1538\u0007\u0018\u0000\u0000\u1538\u1539"+ + "\u0007\u0013\u0000\u0000\u1539\u153a\u0007\u001d\u0000\u0000\u153a\u153b"+ + "\u0007\n\u0000\u0000\u153b\u153c\u0007\r\u0000\u0000\u153c\u0446\u0001"+ + "\u0000\u0000\u0000\u153d\u153e\u0007\r\u0000\u0000\u153e\u153f\u0007\u0005"+ + "\u0000\u0000\u153f\u1540\u0007\f\u0000\u0000\u1540\u1541\u0007\u0011\u0000"+ + "\u0000\u1541\u1542\u0007\u0005\u0000\u0000\u1542\u1543\u0007\u0007\u0000"+ + "\u0000\u1543\u1544\u0007\t\u0000\u0000\u1544\u0448\u0001\u0000\u0000\u0000"+ + "\u1545\u1546\u0007\r\u0000\u0000\u1546\u1547\u0007\u0013\u0000\u0000\u1547"+ + "\u1548\u0007\u0016\u0000\u0000\u1548\u1549\u0007\u0007\u0000\u0000\u1549"+ + "\u154a\u0007\f\u0000\u0000\u154a\u044a\u0001\u0000\u0000\u0000\u154b\u154c"+ + "\u0007\t\u0000\u0000\u154c\u154d\u0007\u000e\u0000\u0000\u154d\u154e\u0007"+ + "\u0005\u0000\u0000\u154e\u154f\u0007\u0006\u0000\u0000\u154f\u1550\u0007"+ + "\n\u0000\u0000\u1550\u044c\u0001\u0000\u0000\u0000\u1551\u1552\u0007\t"+ + "\u0000\u0000\u1552\u1553\u0007\u0011\u0000\u0000\u1553\u1554\u0007\u0017"+ + "\u0000\u0000\u1554\u1555\u0007\u0007\u0000\u0000\u1555\u044e\u0001\u0000"+ + "\u0000\u0000\u1556\u1557\u0007\t\u0000\u0000\u1557\u1558\u0007\u001c\u0000"+ + "\u0000\u1558\u1559\u0007\r\u0000\u0000\u1559\u155a\u0007\u0010\u0000\u0000"+ + "\u155a\u0450\u0001\u0000\u0000\u0000\u155b\u155c\u0007\u0010\u0000\u0000"+ + "\u155c\u155d\u0007\r\u0000\u0000\u155d\u155e\u0007\u0011\u0000\u0000\u155e"+ + "\u155f\u0007\u000f\u0000\u0000\u155f\u1560\u0005_\u0000\u0000\u1560\u1561"+ + "\u0007\t\u0000\u0000\u1561\u1562\u0007\u000e\u0000\u0000\u1562\u1563\u0007"+ + "\u0005\u0000\u0000\u1563\u1564\u0007\u0006\u0000\u0000\u1564\u1565\u0007"+ + "\n\u0000\u0000\u1565\u0452\u0001\u0000\u0000\u0000\u1566\u1567\u0007\u0010"+ + "\u0000\u0000\u1567\u1568\u0007\r\u0000\u0000\u1568\u1569\u0007\u0016\u0000"+ + "\u0000\u1569\u156a\u0007\u0007\u0000\u0000\u156a\u156b\u0007\u000e\u0000"+ + "\u0000\u156b\u0454\u0001\u0000\u0000\u0000\u156c\u156d\u0007\u001d\u0000"+ + "\u0000\u156d\u156e\u0007\u0011\u0000\u0000\u156e\u156f\u0007\f\u0000\u0000"+ + "\u156f\u1570\u0007\u0010\u0000\u0000\u1570\u1571\u0007\u0014\u0000\u0000"+ + "\u1571\u1572\u0005_\u0000\u0000\u1572\u1573\u0007\u0012\u0000\u0000\u1573"+ + "\u1574\u0007\u0016\u0000\u0000\u1574\u1575\u0007\u000e\u0000\u0000\u1575"+ + "\u1576\u0007\u0015\u0000\u0000\u1576\u1577\u0007\n\u0000\u0000\u1577\u1578"+ + "\u0007\u0010\u0000\u0000\u1578\u0456\u0001\u0000\u0000\u0000\u1579\u157a"+ + "\u0007\r\u0000\u0000\u157a\u157b\u0007\u0005\u0000\u0000\u157b\u157c\u0007"+ + "\u0007\u0000\u0000\u157c\u157d\u0007\f\u0000\u0000\u157d\u157e\u0007\u0013"+ + "\u0000\u0000\u157e\u157f\u0007\u000f\u0000\u0000\u157f\u0458\u0001\u0000"+ + "\u0000\u0000\u1580\u1581\u0007\t\u0000\u0000\u1581\u1582\u0007\n\u0000"+ + "\u0000\u1582\u1583\u0007\u0010\u0000\u0000\u1583\u1584\u0007\t\u0000\u0000"+ + "\u1584\u1585\u0007\n\u0000\u0000\u1585\u1586\u0007\n\u0000\u0000\u1586"+ + "\u1587\u0007\f\u0000\u0000\u1587\u045a\u0001\u0000\u0000\u0000\u1588\u1589"+ + "\u0007\u0005\u0000\u0000\u1589\u158a\u0007\u000e\u0000\u0000\u158a\u158b"+ + "\u0007\u0013\u0000\u0000\u158b\u158c\u0007\t\u0000\u0000\u158c\u045c\u0001"+ + "\u0000\u0000\u0000\u158d\u158e\u0007\u0005\u0000\u0000\u158e\u158f\u0007"+ + "\u000e\u0000\u0000\u158f\u1590\u0007\u0013\u0000\u0000\u1590\u1591\u0007"+ + "\t\u0000\u0000\u1591\u1592\u0007\f\u0000\u0000\u1592\u045e\u0001\u0000"+ + "\u0000\u0000\u1593\u1594\u0007\u0005\u0000\u0000\u1594\u1595\u0007\t\u0000"+ + "\u0000\u1595\u1596\u0007\u0011\u0000\u0000\u1596\u1597\u0007\u0007\u0000"+ + "\u0000\u1597\u0460\u0001\u0000\u0000\u0000\u1598\u1599\u0007\u0005\u0000"+ + "\u0000\u1599\u159a\u0007\t\u0000\u0000\u159a\u159b\u0007\u0011\u0000\u0000"+ + "\u159b\u159c\u0007\u0007\u0000\u0000\u159c\u159d\u0007\f\u0000\u0000\u159d"+ + "\u0462\u0001\u0000\u0000\u0000\u159e\u159f\u0007\u0005\u0000\u0000\u159f"+ + "\u15a0\u0007\u0010\u0000\u0000\u15a0\u15a1\u0007\u0005\u0000\u0000\u15a1"+ + "\u15a2\u0007\u0007\u0000\u0000\u15a2\u0464\u0001\u0000\u0000\u0000\u15a3"+ + "\u15a4\u0007\u0005\u0000\u0000\u15a4\u15a5\u0007\u0010\u0000\u0000\u15a5"+ + "\u15a6\u0007\u0005\u0000\u0000\u15a6\u15a7\u0007\u0007\u0000\u0000\u15a7"+ + "\u15a8\u0007\f\u0000\u0000\u15a8\u0466\u0001\u0000\u0000\u0000\u15a9\u15aa"+ + "\u0007\u0005\u0000\u0000\u15aa\u15ab\u0007\u0010\u0000\u0000\u15ab\u15ac"+ + "\u0007\u0005\u0000\u0000\u15ac\u15ad\u0007\u0007\u0000\u0000\u15ad\u15ae"+ + "\u00052\u0000\u0000\u15ae\u0468\u0001\u0000\u0000\u0000\u15af\u15b0\u0007"+ + "\u0005\u0000\u0000\u15b0\u15b1\u0007\u0010\u0000\u0000\u15b1\u15b2\u0007"+ + "\u0005\u0000\u0000\u15b2\u15b3\u0007\u0007\u0000\u0000\u15b3\u15b4\u0005"+ + "2\u0000\u0000\u15b4\u15b5\u0007\f\u0000\u0000\u15b5\u046a\u0001\u0000"+ + "\u0000\u0000\u15b6\u15b7\u0007\u000e\u0000\u0000\u15b7\u15b8\u0007\u0013"+ + "\u0000\u0000\u15b8\u15b9\u0007\t\u0000\u0000\u15b9\u046c\u0001\u0000\u0000"+ + "\u0000\u15ba\u15bb\u0007\u000e\u0000\u0000\u15bb\u15bc\u0007\u0013\u0000"+ + "\u0000\u15bc\u15bd\u0007\t\u0000\u0000\u15bd\u15be\u0007\f\u0000\u0000"+ + "\u15be\u046e\u0001\u0000\u0000\u0000\u15bf\u15c0\u0007\u000e\u0000\u0000"+ + "\u15c0\u15c1\u0007\u0013\u0000\u0000\u15c1\u15c2\u0007\u0010\u0000\u0000"+ + "\u15c2\u0470\u0001\u0000\u0000\u0000\u15c3\u15c4\u0007\u000e\u0000\u0000"+ + "\u15c4\u15c5\u0007\u0013\u0000\u0000\u15c5\u15c6\u0007\u0010\u0000\u0000"+ + "\u15c6\u15c7\u0007\f\u0000\u0000\u15c7\u0472\u0001\u0000\u0000\u0000\u15c8"+ + "\u15c9\u0007\t\u0000\u0000\u15c9\u15ca\u0007\u0011\u0000\u0000\u15ca\u15cb"+ + "\u0007\u0007\u0000\u0000\u15cb\u0474\u0001\u0000\u0000\u0000\u15cc\u15cd"+ + "\u0007\t\u0000\u0000\u15cd\u15ce\u0007\u0011\u0000\u0000\u15ce\u15cf\u0007"+ + "\u0007\u0000\u0000\u15cf\u15d0\u0007\f\u0000\u0000\u15d0\u0476\u0001\u0000"+ + "\u0000\u0000\u15d1\u15d2\u0007\u0010\u0000\u0000\u15d2\u15d3\u0007\u0005"+ + "\u0000\u0000\u15d3\u15d4\u0007\u0007\u0000\u0000\u15d4\u0478\u0001\u0000"+ + "\u0000\u0000\u15d5\u15d6\u0007\u0010\u0000\u0000\u15d6\u15d7\u0007\u0005"+ + "\u0000\u0000\u15d7\u15d8\u0007\u0007\u0000\u0000\u15d8\u15d9\u0007\f\u0000"+ + "\u0000\u15d9\u047a\u0001\u0000\u0000\u0000\u15da\u15db\u0007\t\u0000\u0000"+ + "\u15db\u15dc\u0007\u0011\u0000\u0000\u15dc\u15dd\u0007\u0007\u0000\u0000"+ + "\u15dd\u15de\u0007\u0014\u0000\u0000\u15de\u047c\u0001\u0000\u0000\u0000"+ + "\u15df\u15e0\u0007\u000e\u0000\u0000\u15e0\u15e1\u0007\u0013\u0000\u0000"+ + "\u15e1\u15e2\u0007\t\u0000\u0000\u15e2\u15e3\u0007\u0014\u0000\u0000\u15e3"+ + "\u047e\u0001\u0000\u0000\u0000\u15e4\u15e5\u0007\u0010\u0000\u0000\u15e5"+ + "\u15e6\u0007\u0005\u0000\u0000\u15e6\u15e7\u0007\u0007\u0000\u0000\u15e7"+ + "\u15e8\u0007\u0014\u0000\u0000\u15e8\u0480\u0001\u0000\u0000\u0000\u15e9"+ + "\u15ea\u0007\u0005\u0000\u0000\u15ea\u15eb\u0007\t\u0000\u0000\u15eb\u15ec"+ + "\u0007\u0011\u0000\u0000\u15ec\u15ed\u0007\u0007\u0000\u0000\u15ed\u15ee"+ + "\u0007\u0014\u0000\u0000\u15ee\u0482\u0001\u0000\u0000\u0000\u15ef\u15f0"+ + "\u0007\u0005\u0000\u0000\u15f0\u15f1\u0007\u000e\u0000\u0000\u15f1\u15f2"+ + "\u0007\u0013\u0000\u0000\u15f2\u15f3\u0007\t\u0000\u0000\u15f3\u15f4\u0007"+ + "\u0014\u0000\u0000\u15f4\u0484\u0001\u0000\u0000\u0000\u15f5\u15f6\u0007"+ + "\u0005\u0000\u0000\u15f6\u15f7\u0007\u0010\u0000\u0000\u15f7\u15f8\u0007"+ + "\u0005\u0000\u0000\u15f8\u15f9\u0007\u0007\u0000\u0000\u15f9\u15fa\u0007"+ + "\u0014\u0000\u0000\u15fa\u0486\u0001\u0000\u0000\u0000\u15fb\u15fc\u0007"+ + "\u0012\u0000\u0000\u15fc\u15fd\u0007\u0011\u0000\u0000\u15fd\u15fe\u0007"+ + "\u0010\u0000\u0000\u15fe\u15ff\u0005_\u0000\u0000\u15ff\u1600\u0007\u0006"+ + "\u0000\u0000\u1600\u1601\u0007\n\u0000\u0000\u1601\u1602\u0007\u0007\u0000"+ + "\u0000\u1602\u1603\u0007\u0017\u0000\u0000\u1603\u1604\u0007\u0010\u0000"+ + "\u0000\u1604\u1605\u0007\u0014\u0000\u0000\u1605\u0488\u0001\u0000\u0000"+ + "\u0000\u1606\u1607\u0007\u000e\u0000\u0000\u1607\u1608\u0007\u0014\u0000"+ + "\u0000\u1608\u1609\u0007\u0005\u0000\u0000\u1609\u160a\u0007\r\u0000\u0000"+ + "\u160a\u160b\u0005_\u0000\u0000\u160b\u160c\u0007\u0006\u0000\u0000\u160c"+ + "\u160d\u0007\n\u0000\u0000\u160d\u160e\u0007\u0007\u0000\u0000\u160e\u160f"+ + "\u0007\u0017\u0000\u0000\u160f\u1610\u0007\u0010\u0000\u0000\u1610\u1611"+ + "\u0007\u0014\u0000\u0000\u1611\u048a\u0001\u0000\u0000\u0000\u1612\u1613"+ + "\u0007\u000e\u0000\u0000\u1613\u1614\u0007\u0014\u0000\u0000\u1614\u1615"+ + "\u0007\u0005\u0000\u0000\u1615\u1616\u0007\r\u0000\u0000\u1616\u1617\u0007"+ + "\u0005\u0000\u0000\u1617\u1618\u0007\u000e\u0000\u0000\u1618\u1619\u0007"+ + "\u0010\u0000\u0000\u1619\u161a\u0007\n\u0000\u0000\u161a\u161b\u0007\r"+ + "\u0000\u0000\u161b\u161c\u0005_\u0000\u0000\u161c\u161d\u0007\u0006\u0000"+ + "\u0000\u161d\u161e\u0007\n\u0000\u0000\u161e\u161f\u0007\u0007\u0000\u0000"+ + "\u161f\u1620\u0007\u0017\u0000\u0000\u1620\u1621\u0007\u0010\u0000\u0000"+ + "\u1621\u1622\u0007\u0014\u0000\u0000\u1622\u048c\u0001\u0000\u0000\u0000"+ + "\u1623\u1624\u0007\u0006\u0000\u0000\u1624\u1625\u0007\u0013\u0000\u0000"+ + "\u1625\u1626\u0007\u001d\u0000\u0000\u1626\u1627\u0007\n\u0000\u0000\u1627"+ + "\u1628\u0007\r\u0000\u0000\u1628\u048e\u0001\u0000\u0000\u0000\u1629\u162a"+ + "\u0007\u0013\u0000\u0000\u162a\u162b\u0007\u000e\u0000\u0000\u162b\u162c"+ + "\u0007\u0010\u0000\u0000\u162c\u162d\u0007\n\u0000\u0000\u162d\u162e\u0007"+ + "\u0010\u0000\u0000\u162e\u162f\u0005_\u0000\u0000\u162f\u1630\u0007\u0006"+ + "\u0000\u0000\u1630\u1631\u0007\n\u0000\u0000\u1631\u1632\u0007\u0007\u0000"+ + "\u0000\u1632\u1633\u0007\u0017\u0000\u0000\u1633\u1634\u0007\u0010\u0000"+ + "\u0000\u1634\u1635\u0007\u0014\u0000\u0000\u1635\u0490\u0001\u0000\u0000"+ + "\u0000\u1636\u1637\u0007\u0016\u0000\u0000\u1637\u1638\u0007\u0018\u0000"+ + "\u0000\u1638\u1639\u0007\u0018\u0000\u0000\u1639\u163a\u0007\n\u0000\u0000"+ + "\u163a\u163b\u0007\r\u0000\u0000\u163b\u0492\u0001\u0000\u0000\u0000\u163c"+ + "\u163d\u0007\u0005\u0000\u0000\u163d\u163e\u0007\t\u0000\u0000\u163e\u163f"+ + "\u0007\u000e\u0000\u0000\u163f\u1640\u0007\u0011\u0000\u0000\u1640\u1641"+ + "\u0007\u0011\u0000\u0000\u1641\u0494\u0001\u0000\u0000\u0000\u1642\u1643"+ + "\u0007\u0012\u0000\u0000\u1643\u1644\u0007\u0010\u0000\u0000\u1644\u1645"+ + "\u0007\r\u0000\u0000\u1645\u1646\u0007\u0011\u0000\u0000\u1646\u1647\u0007"+ + "\u000f\u0000\u0000\u1647\u0496\u0001\u0000\u0000\u0000\u1648\u1649\u0007"+ + "\u000e\u0000\u0000\u1649\u164a\u0007\u0014\u0000\u0000\u164a\u164b\u0007"+ + "\r\u0000\u0000\u164b\u0498\u0001\u0000\u0000\u0000\u164c\u164d\u0007\u000e"+ + "\u0000\u0000\u164d\u164e\u0007\u0013\u0000\u0000\u164e\u164f\u0007\u0007"+ + "\u0000\u0000\u164f\u1650\u0007\u000e\u0000\u0000\u1650\u1651\u0007\u0005"+ + "\u0000\u0000\u1651\u1652\u0007\u0010\u0000\u0000\u1652\u049a\u0001\u0000"+ + "\u0000\u0000\u1653\u1654\u0007\u000e\u0000\u0000\u1654\u1655\u0007\u0013"+ + "\u0000\u0000\u1655\u1656\u0007\u0007\u0000\u0000\u1656\u1657\u0007\u000e"+ + "\u0000\u0000\u1657\u1658\u0007\u0005\u0000\u0000\u1658\u1659\u0007\u0010"+ + "\u0000\u0000\u1659\u165a\u0005_\u0000\u0000\u165a\u165b\u0007\u001d\u0000"+ + "\u0000\u165b\u165c\u0007\t\u0000\u0000\u165c\u049c\u0001\u0000\u0000\u0000"+ + "\u165d\u165e\u0007\u0019\u0000\u0000\u165e\u165f\u0007\u0013\u0000\u0000"+ + "\u165f\u1660\u0007\r\u0000\u0000\u1660\u1661\u0007\u000f\u0000\u0000\u1661"+ + "\u1662\u0007\u0005\u0000\u0000\u1662\u1663\u0007\u0010\u0000\u0000\u1663"+ + "\u049e\u0001\u0000\u0000\u0000\u1664\u1665\u0007\u0011\u0000\u0000\u1665"+ + "\u1666\u0007\u0007\u0000\u0000\u1666\u1667\u0007\u0011\u0000\u0000\u1667"+ + "\u1668\u0007\u0010\u0000\u0000\u1668\u1669\u0007\u000e\u0000\u0000\u1669"+ + "\u166a\u0007\u0005\u0000\u0000\u166a\u166b\u0007\u0018\u0000\u0000\u166b"+ + "\u04a0\u0001\u0000\u0000\u0000\u166c\u166d\u0007\u0006\u0000\u0000\u166d"+ + "\u166e\u0007\n\u0000\u0000\u166e\u166f\u0007\u0007\u0000\u0000\u166f\u1670"+ + "\u0007\u0017\u0000\u0000\u1670\u1671\u0007\u0010\u0000\u0000\u1671\u1672"+ + "\u0007\u0014\u0000\u0000\u1672\u04a2\u0001\u0000\u0000\u0000\u1673\u1674"+ + "\u0007\u0006\u0000\u0000\u1674\u1675\u0007\u0018\u0000\u0000\u1675\u1676"+ + "\u0007\u0005\u0000\u0000\u1676\u1677\u0007\f\u0000\u0000\u1677\u04a4\u0001"+ + "\u0000\u0000\u0000\u1678\u1679\u0007\u0006\u0000\u0000\u1679\u167a\u0007"+ + "\u0010\u0000\u0000\u167a\u167b\u0007\r\u0000\u0000\u167b\u167c\u0007\u0011"+ + "\u0000\u0000\u167c\u167d\u0007\u000f\u0000\u0000\u167d\u04a6\u0001\u0000"+ + "\u0000\u0000\u167e\u167f\u0007\u000f\u0000\u0000\u167f\u1680\u0007\f\u0000"+ + "\u0000\u1680\u1681\u00055\u0000\u0000\u1681\u04a8\u0001\u0000\u0000\u0000"+ + "\u1682\u1683\u0007\u0018\u0000\u0000\u1683\u1684\u0007\u0005\u0000\u0000"+ + "\u1684\u1685\u0007\r\u0000\u0000\u1685\u1686\u0007\t\u0000\u0000\u1686"+ + "\u1687\u0007\n\u0000\u0000\u1687\u1688\u0005_\u0000\u0000\u1688\u1689"+ + "\u0007\u0011\u0000\u0000\u1689\u168a\u0007\f\u0000\u0000\u168a\u168b\u0007"+ + "\n\u0000\u0000\u168b\u168c\u0007\u0007\u0000\u0000\u168c\u168d\u0007\u0010"+ + "\u0000\u0000\u168d\u04aa\u0001\u0000\u0000\u0000\u168e\u168f\u0007\u0018"+ + "\u0000\u0000\u168f\u1690\u0007\u0017\u0000\u0000\u1690\u1691\u0005_\u0000"+ + "\u0000\u1691\u1692\u0007\u000e\u0000\u0000\u1692\u1693\u0007\u0006\u0000"+ + "\u0000\u1693\u1694\u0007\u0011\u0000\u0000\u1694\u1695\u0007\n\u0000\u0000"+ + "\u1695\u1696\u0007\u0007\u0000\u0000\u1696\u1697\u0007\u0010\u0000\u0000"+ + "\u1697\u1698\u0005_\u0000\u0000\u1698\u1699\u0007\n\u0000\u0000\u1699"+ + "\u169a\u0007\u0007\u0000\u0000\u169a\u169b\u0007\u000e\u0000\u0000\u169b"+ + "\u169c\u0007\u0013\u0000\u0000\u169c\u169d\u0007\f\u0000\u0000\u169d\u169e"+ + "\u0007\u0011\u0000\u0000\u169e\u169f\u0007\u0007\u0000\u0000\u169f\u16a0"+ + "\u0007\u0017\u0000\u0000\u16a0\u04ac\u0001\u0000\u0000\u0000\u16a1\u16a2"+ + "\u0007\u001c\u0000\u0000\u16a2\u16a3\u0007\u0016\u0000\u0000\u16a3\u16a4"+ + "\u0007\u0013\u0000\u0000\u16a4\u16a5\u0007\u0010\u0000\u0000\u16a5\u16a6"+ + "\u0007\n\u0000\u0000\u16a6\u16a7\u0005_\u0000\u0000\u16a7\u16a8\u0007"+ + "\u0011\u0000\u0000\u16a8\u16a9\u0007\f\u0000\u0000\u16a9\u16aa\u0007\n"+ + "\u0000\u0000\u16aa\u16ab\u0007\u0007\u0000\u0000\u16ab\u16ac\u0007\u0010"+ + "\u0000\u0000\u16ac\u04ae\u0001\u0000\u0000\u0000\u16ad\u16ae\u0007\u001c"+ + "\u0000\u0000\u16ae\u16af\u0007\u0016\u0000\u0000\u16af\u16b0\u0007\u0013"+ + "\u0000\u0000\u16b0\u16b1\u0007\u0010\u0000\u0000\u16b1\u16b2\u0007\n\u0000"+ + "\u0000\u16b2\u16b3\u0005_\u0000\u0000\u16b3\u16b4\u0007\u0006\u0000\u0000"+ + "\u16b4\u16b5\u0007\u0011\u0000\u0000\u16b5\u16b6\u0007\u0010\u0000\u0000"+ + "\u16b6\u16b7\u0007\n\u0000\u0000\u16b7\u16b8\u0007\r\u0000\u0000\u16b8"+ + "\u16b9\u0007\u0005\u0000\u0000\u16b9\u16ba\u0007\u0006\u0000\u0000\u16ba"+ + "\u04b0\u0001\u0000\u0000\u0000\u16bb\u16bc\u0007\u001c\u0000\u0000\u16bc"+ + "\u16bd\u0007\u0016\u0000\u0000\u16bd\u16be\u0007\u0013\u0000\u0000\u16be"+ + "\u16bf\u0007\u0010\u0000\u0000\u16bf\u16c0\u0007\n\u0000\u0000\u16c0\u16c1"+ + "\u0005_\u0000\u0000\u16c1\u16c2\u0007\u0007\u0000\u0000\u16c2\u16c3\u0007"+ + "\u0016\u0000\u0000\u16c3\u16c4\u0007\u0006\u0000\u0000\u16c4\u16c5\u0007"+ + "\u0006\u0000\u0000\u16c5\u16c6\u0007\u0005\u0000\u0000\u16c6\u16c7\u0007"+ + "\u0012\u0000\u0000\u16c7\u16c8\u0007\u0006\u0000\u0000\u16c8\u16c9\u0007"+ + "\n\u0000\u0000\u16c9\u04b2\u0001\u0000\u0000\u0000\u16ca\u16cb\u0007\r"+ + "\u0000\u0000\u16cb\u16cc\u0007\n\u0000\u0000\u16cc\u16cd\u0007\u0017\u0000"+ + "\u0000\u16cd\u16ce\u0007\n\u0000\u0000\u16ce\u16cf\u0007\u001a\u0000\u0000"+ + "\u16cf\u16d0\u0007\u0018\u0000\u0000\u16d0\u16d1\u0005_\u0000\u0000\u16d1"+ + "\u16d2\u0007\u000e\u0000\u0000\u16d2\u16d3\u0007\u0013\u0000\u0000\u16d3"+ + "\u16d4\u0007\u0016\u0000\u0000\u16d4\u16d5\u0007\u0007\u0000\u0000\u16d5"+ + "\u16d6\u0007\u0010\u0000\u0000\u16d6\u04b4\u0001\u0000\u0000\u0000\u16d7"+ + "\u16d8\u0007\r\u0000\u0000\u16d8\u16d9\u0007\n\u0000\u0000\u16d9\u16da"+ + "\u0007\u0017\u0000\u0000\u16da\u16db\u0007\n\u0000\u0000\u16db\u16dc\u0007"+ + "\u001a\u0000\u0000\u16dc\u16dd\u0007\u0018\u0000\u0000\u16dd\u16de\u0005"+ + "_\u0000\u0000\u16de\u16df\u0007\u0011\u0000\u0000\u16df\u16e0\u0007\u0007"+ + "\u0000\u0000\u16e0\u16e1\u0007\t\u0000\u0000\u16e1\u16e2\u0007\u0010\u0000"+ + "\u0000\u16e2\u16e3\u0007\r\u0000\u0000\u16e3\u04b6\u0001\u0000\u0000\u0000"+ + "\u16e4\u16e5\u0007\r\u0000\u0000\u16e5\u16e6\u0007\n\u0000\u0000\u16e6"+ + "\u16e7\u0007\u0017\u0000\u0000\u16e7\u16e8\u0007\n\u0000\u0000\u16e8\u16e9"+ + "\u0007\u001a\u0000\u0000\u16e9\u16ea\u0007\u0018\u0000\u0000\u16ea\u16eb"+ + "\u0005_\u0000\u0000\u16eb\u16ec\u0007\u0006\u0000\u0000\u16ec\u16ed\u0007"+ + "\u0011\u0000\u0000\u16ed\u16ee\u0007\u0015\u0000\u0000\u16ee\u16ef\u0007"+ + "\n\u0000\u0000\u16ef\u04b8\u0001\u0000\u0000\u0000\u16f0\u16f1\u0007\r"+ + "\u0000\u0000\u16f1\u16f2\u0007\n\u0000\u0000\u16f2\u16f3\u0007\u0017\u0000"+ + "\u0000\u16f3\u16f4\u0007\n\u0000\u0000\u16f4\u16f5\u0007\u001a\u0000\u0000"+ + "\u16f5\u16f6\u0007\u0018\u0000\u0000\u16f6\u16f7\u0005_\u0000\u0000\u16f7"+ + "\u16f8\u0007\u000f\u0000\u0000\u16f8\u16f9\u0007\u0005\u0000\u0000\u16f9"+ + "\u16fa\u0007\u0010\u0000\u0000\u16fa\u16fb\u0007\u000e\u0000\u0000\u16fb"+ + "\u16fc\u0007\u0014\u0000\u0000\u16fc\u04ba\u0001\u0000\u0000\u0000\u16fd"+ + "\u16fe\u0007\r\u0000\u0000\u16fe\u16ff\u0007\n\u0000\u0000\u16ff\u1700"+ + "\u0007\u0017\u0000\u0000\u1700\u1701\u0007\n\u0000\u0000\u1701\u1702\u0007"+ + "\u001a\u0000\u0000\u1702\u1703\u0007\u0018\u0000\u0000\u1703\u1704\u0005"+ + "_\u0000\u0000\u1704\u1705\u0007\u000f\u0000\u0000\u1705\u1706\u0007\u0005"+ + "\u0000\u0000\u1706\u1707\u0007\u0010\u0000\u0000\u1707\u1708\u0007\u000e"+ + "\u0000\u0000\u1708\u1709\u0007\u0014\u0000\u0000\u1709\u170a\u0007\n\u0000"+ + "\u0000\u170a\u170b\u0007\t\u0000\u0000\u170b\u04bc\u0001\u0000\u0000\u0000"+ + "\u170c\u170d\u0007\r\u0000\u0000\u170d\u170e\u0007\n\u0000\u0000\u170e"+ + "\u170f\u0007\u0017\u0000\u0000\u170f\u1710\u0007\n\u0000\u0000\u1710\u1711"+ + "\u0007\u001a\u0000\u0000\u1711\u1712\u0007\u0018\u0000\u0000\u1712\u1713"+ + "\u0005_\u0000\u0000\u1713\u1714\u0007\r\u0000\u0000\u1714\u1715\u0007"+ + "\n\u0000\u0000\u1715\u1716\u0007\u0018\u0000\u0000\u1716\u1717\u0007\u0006"+ + "\u0000\u0000\u1717\u1718\u0007\u0005\u0000\u0000\u1718\u1719\u0007\u000e"+ + "\u0000\u0000\u1719\u171a\u0007\n\u0000\u0000\u171a\u04be\u0001\u0000\u0000"+ + "\u0000\u171b\u171c\u0007\r\u0000\u0000\u171c\u171d\u0007\n\u0000\u0000"+ + "\u171d\u171e\u0007\u0017\u0000\u0000\u171e\u171f\u0007\n\u0000\u0000\u171f"+ + "\u1720\u0007\u001a\u0000\u0000\u1720\u1721\u0007\u0018\u0000\u0000\u1721"+ + "\u1722\u0005_\u0000\u0000\u1722\u1723\u0007\t\u0000\u0000\u1723\u1724"+ + "\u0007\u0018\u0000\u0000\u1724\u1725\u0007\u0006\u0000\u0000\u1725\u1726"+ + "\u0007\u0011\u0000\u0000\u1726\u1727\u0007\u0010\u0000\u0000\u1727\u1728"+ + "\u0005_\u0000\u0000\u1728\u1729\u0007\u0010\u0000\u0000\u1729\u172a\u0007"+ + "\u0013\u0000\u0000\u172a\u172b\u0005_\u0000\u0000\u172b\u172c\u0007\u0005"+ + "\u0000\u0000\u172c\u172d\u0007\r\u0000\u0000\u172d\u172e\u0007\r\u0000"+ + "\u0000\u172e\u172f\u0007\u0005\u0000\u0000\u172f\u1730\u0007\b\u0000\u0000"+ + "\u1730\u04c0\u0001\u0000\u0000\u0000\u1731\u1732\u0007\r\u0000\u0000\u1732"+ + "\u1733\u0007\n\u0000\u0000\u1733\u1734\u0007\u0017\u0000\u0000\u1734\u1735"+ + "\u0007\n\u0000\u0000\u1735\u1736\u0007\u001a\u0000\u0000\u1736\u1737\u0007"+ + "\u0018\u0000\u0000\u1737\u1738\u0005_\u0000\u0000\u1738\u1739\u0007\t"+ + "\u0000\u0000\u1739\u173a\u0007\u0018\u0000\u0000\u173a\u173b\u0007\u0006"+ + "\u0000\u0000\u173b\u173c\u0007\u0011\u0000\u0000\u173c\u173d\u0007\u0010"+ + "\u0000\u0000\u173d\u173e\u0005_\u0000\u0000\u173e\u173f\u0007\u0010\u0000"+ + "\u0000\u173f\u1740\u0007\u0013\u0000\u0000\u1740\u1741\u0005_\u0000\u0000"+ + "\u1741\u1742\u0007\u0010\u0000\u0000\u1742\u1743\u0007\u0005\u0000\u0000"+ + "\u1743\u1744\u0007\u0012\u0000\u0000\u1744\u1745\u0007\u0006\u0000\u0000"+ + "\u1745\u1746\u0007\n\u0000\u0000\u1746\u04c2\u0001\u0000\u0000\u0000\u1747"+ + "\u1748\u0007\r\u0000\u0000\u1748\u1749\u0007\n\u0000\u0000\u1749\u174a"+ + "\u0007\u0017\u0000\u0000\u174a\u174b\u0007\n\u0000\u0000\u174b\u174c\u0007"+ + "\u001a\u0000\u0000\u174c\u174d\u0007\u0018\u0000\u0000\u174d\u174e\u0005"+ + "_\u0000\u0000\u174e\u174f\u0007\t\u0000\u0000\u174f\u1750\u0007\u0016"+ + "\u0000\u0000\u1750\u1751\u0007\u0012\u0000\u0000\u1751\u1752\u0007\t\u0000"+ + "\u0000\u1752\u1753\u0007\u0010\u0000\u0000\u1753\u1754\u0007\r\u0000\u0000"+ + "\u1754\u04c4\u0001\u0000\u0000\u0000\u1755\u1756\u0007\r\u0000\u0000\u1756"+ + "\u1757\u0007\n\u0000\u0000\u1757\u1758\u0007\u0018\u0000\u0000\u1758\u1759"+ + "\u0007\n\u0000\u0000\u1759\u175a\u0007\u0005\u0000\u0000\u175a\u175b\u0007"+ + "\u0010\u0000\u0000\u175b\u04c6\u0001\u0000\u0000\u0000\u175c\u175d\u0007"+ + "\r\u0000\u0000\u175d\u175e\u0007\u0018\u0000\u0000\u175e\u175f\u0007\u0005"+ + "\u0000\u0000\u175f\u1760\u0007\f\u0000\u0000\u1760\u04c8\u0001\u0000\u0000"+ + "\u0000\u1761\u1762\u0007\r\u0000\u0000\u1762\u1763\u0007\u0010\u0000\u0000"+ + "\u1763\u1764\u0007\r\u0000\u0000\u1764\u1765\u0007\u0011\u0000\u0000\u1765"+ + "\u1766\u0007\u000f\u0000\u0000\u1766\u04ca\u0001\u0000\u0000\u0000\u1767"+ + "\u1768\u0007\t\u0000\u0000\u1768\u1769\u0007\u0018\u0000\u0000\u1769\u176a"+ + "\u0007\u0006\u0000\u0000\u176a\u176b\u0007\u0011\u0000\u0000\u176b\u176c"+ + "\u0007\u0010\u0000\u0000\u176c\u176d\u0005_\u0000\u0000\u176d\u176e\u0007"+ + "\u0018\u0000\u0000\u176e\u176f\u0007\u0005\u0000\u0000\u176f\u1770\u0007"+ + "\r\u0000\u0000\u1770\u1771\u0007\u0010\u0000\u0000\u1771\u04cc\u0001\u0000"+ + "\u0000\u0000\u1772\u1773\u0007\t\u0000\u0000\u1773\u1774\u0007\u0010\u0000"+ + "\u0000\u1774\u1775\u0007\u0005\u0000\u0000\u1775\u1776\u0007\r\u0000\u0000"+ + "\u1776\u1777\u0007\u0010\u0000\u0000\u1777\u1778\u0007\t\u0000\u0000\u1778"+ + "\u1779\u0005_\u0000\u0000\u1779\u177a\u0007\u001d\u0000\u0000\u177a\u177b"+ + "\u0007\u0011\u0000\u0000\u177b\u177c\u0007\u0010\u0000\u0000\u177c\u177d"+ + "\u0007\u0014\u0000\u0000\u177d\u04ce\u0001\u0000\u0000\u0000\u177e\u177f"+ + "\u0007\t\u0000\u0000\u177f\u1780\u0007\u0010\u0000\u0000\u1780\u1781\u0007"+ + "\r\u0000\u0000\u1781\u1782\u0007\u0011\u0000\u0000\u1782\u1783\u0007\u0007"+ + "\u0000\u0000\u1783\u1784\u0007\u0017\u0000\u0000\u1784\u1785\u0005_\u0000"+ + "\u0000\u1785\u1786\u0007\u0010\u0000\u0000\u1786\u1787\u0007\u0013\u0000"+ + "\u0000\u1787\u1788\u0005_\u0000\u0000\u1788\u1789\u0007\u0005\u0000\u0000"+ + "\u1789\u178a\u0007\r\u0000\u0000\u178a\u178b\u0007\r\u0000\u0000\u178b"+ + "\u178c\u0007\u0005\u0000\u0000\u178c\u178d\u0007\b\u0000\u0000\u178d\u04d0"+ + "\u0001\u0000\u0000\u0000\u178e\u178f\u0007\t\u0000\u0000\u178f\u1790\u0007"+ + "\u0010\u0000\u0000\u1790\u1791\u0007\r\u0000\u0000\u1791\u1792\u0007\u0011"+ + "\u0000\u0000\u1792\u1793\u0007\u0007\u0000\u0000\u1793\u1794\u0007\u0017"+ + "\u0000\u0000\u1794\u1795\u0005_\u0000\u0000\u1795\u1796\u0007\u0010\u0000"+ + "\u0000\u1796\u1797\u0007\u0013\u0000\u0000\u1797\u1798\u0005_\u0000\u0000"+ + "\u1798\u1799\u0007\u0010\u0000\u0000\u1799\u179a\u0007\u0005\u0000\u0000"+ + "\u179a\u179b\u0007\u0012\u0000\u0000\u179b\u179c\u0007\u0006\u0000\u0000"+ + "\u179c\u179d\u0007\n\u0000\u0000\u179d\u04d2\u0001\u0000\u0000\u0000\u179e"+ + "\u179f\u0007\t\u0000\u0000\u179f\u17a0\u0007\u0010\u0000\u0000\u17a0\u17a1"+ + "\u0007\r\u0000\u0000\u17a1\u17a2\u0007\u0018\u0000\u0000\u17a2\u17a3\u0007"+ + "\u0013\u0000\u0000\u17a3\u17a4\u0007\t\u0000\u0000\u17a4\u04d4\u0001\u0000"+ + "\u0000\u0000\u17a5\u17a6\u0007\t\u0000\u0000\u17a6\u17a7\u0007\u0016\u0000"+ + "\u0000\u17a7\u17a8\u0007\u0012\u0000\u0000\u17a8\u17a9\u0007\t\u0000\u0000"+ + "\u17a9\u17aa\u0007\u0010\u0000\u0000\u17aa\u17ab\u0007\r\u0000\u0000\u17ab"+ + "\u04d6\u0001\u0000\u0000\u0000\u17ac\u17ad\u0007\u0010\u0000\u0000\u17ad"+ + "\u17ae\u0007\u0013\u0000\u0000\u17ae\u17af\u0005_\u0000\u0000\u17af\u17b0"+ + "\u0007\u0005\u0000\u0000\u17b0\u17b1\u0007\t\u0000\u0000\u17b1\u17b2\u0007"+ + "\u000e\u0000\u0000\u17b2\u17b3\u0007\u0011\u0000\u0000\u17b3\u17b4\u0007"+ + "\u0011\u0000\u0000\u17b4\u04d8\u0001\u0000\u0000\u0000\u17b5\u17b6\u0007"+ + "\u0010\u0000\u0000\u17b6\u17b7\u0007\u0013\u0000\u0000\u17b7\u17b8\u0005"+ + "_\u0000\u0000\u17b8\u17b9\u0007\u0014\u0000\u0000\u17b9\u17ba\u0007\n"+ + "\u0000\u0000\u17ba\u17bb\u0007\u001a\u0000\u0000\u17bb\u04da\u0001\u0000"+ + "\u0000\u0000\u17bc\u17bd\u0007\u0010\u0000\u0000\u17bd\u17be\u0007\r\u0000"+ + "\u0000\u17be\u17bf\u0007\u0005\u0000\u0000\u17bf\u17c0\u0007\u0007\u0000"+ + "\u0000\u17c0\u17c1\u0007\t\u0000\u0000\u17c1\u17c2\u0007\u0006\u0000\u0000"+ + "\u17c2\u17c3\u0007\u0005\u0000\u0000\u17c3\u17c4\u0007\u0010\u0000\u0000"+ + "\u17c4\u17c5\u0007\n\u0000\u0000\u17c5\u04dc\u0001\u0000\u0000\u0000\u17c6"+ + "\u17c7\u0007\u0016\u0000\u0000\u17c7\u17c8\u0007\u0007\u0000\u0000\u17c8"+ + "\u17c9\u0007\u0011\u0000\u0000\u17c9\u17ca\u0007\t\u0000\u0000\u17ca\u17cb"+ + "\u0007\u0010\u0000\u0000\u17cb\u17cc\u0007\r\u0000\u0000\u17cc\u04de\u0001"+ + "\u0000\u0000\u0000\u17cd\u17ce\u0007\u0005\u0000\u0000\u17ce\u17cf\u0007"+ + "\u0017\u0000\u0000\u17cf\u17d0\u0007\n\u0000\u0000\u17d0\u04e0\u0001\u0000"+ + "\u0000\u0000\u17d1\u17d2\u0007\u000e\u0000\u0000\u17d2\u17d3\u0007\u0006"+ + "\u0000\u0000\u17d3\u17d4\u0007\u0013\u0000\u0000\u17d4\u17d5\u0007\u000e"+ + "\u0000\u0000\u17d5\u17d6\u0007\u0015\u0000\u0000\u17d6\u17d7\u0005_\u0000"+ + "\u0000\u17d7\u17d8\u0007\u0010\u0000\u0000\u17d8\u17d9\u0007\u0011\u0000"+ + "\u0000\u17d9\u17da\u0007\u000f\u0000\u0000\u17da\u17db\u0007\n\u0000\u0000"+ + "\u17db\u17dc\u0007\t\u0000\u0000\u17dc\u17dd\u0007\u0010\u0000\u0000\u17dd"+ + "\u17de\u0007\u0005\u0000\u0000\u17de\u17df\u0007\u000f\u0000\u0000\u17df"+ + "\u17e0\u0007\u0018\u0000\u0000\u17e0\u04e2\u0001\u0000\u0000\u0000\u17e1"+ + "\u17e2\u0007\f\u0000\u0000\u17e2\u17e3\u0007\u0005\u0000\u0000\u17e3\u17e4"+ + "\u0007\u0010\u0000\u0000\u17e4\u17e5\u0007\n\u0000\u0000\u17e5\u17e6\u0005"+ + "_\u0000\u0000\u17e6\u17e7\u0007\u0012\u0000\u0000\u17e7\u17e8\u0007\u0011"+ + "\u0000\u0000\u17e8\u17e9\u0007\u0007\u0000\u0000\u17e9\u04e4\u0001\u0000"+ + "\u0000\u0000\u17ea\u17eb\u0007\f\u0000\u0000\u17eb\u17ec\u0007\u0005\u0000"+ + "\u0000\u17ec\u17ed\u0007\u0010\u0000\u0000\u17ed\u17ee\u0007\n\u0000\u0000"+ + "\u17ee\u17ef\u0005_\u0000\u0000\u17ef\u17f0\u0007\u0018\u0000\u0000\u17f0"+ + "\u17f1\u0007\u0005\u0000\u0000\u17f1\u17f2\u0007\r\u0000\u0000\u17f2\u17f3"+ + "\u0007\u0010\u0000\u0000\u17f3\u04e6\u0001\u0000\u0000\u0000\u17f4\u17f5"+ + "\u0007\f\u0000\u0000\u17f5\u17f6\u0007\u0005\u0000\u0000\u17f6\u17f7\u0007"+ + "\u0010\u0000\u0000\u17f7\u17f8\u0007\n\u0000\u0000\u17f8\u17f9\u0005_"+ + "\u0000\u0000\u17f9\u17fa\u0007\u0010\u0000\u0000\u17fa\u17fb\u0007\r\u0000"+ + "\u0000\u17fb\u17fc\u0007\u0016\u0000\u0000\u17fc\u17fd\u0007\u0007\u0000"+ + "\u0000\u17fd\u17fe\u0007\u000e\u0000\u0000\u17fe\u04e8\u0001\u0000\u0000"+ + "\u0000\u17ff\u1800\u0007\u0011\u0000\u0000\u1800\u1801\u0007\t\u0000\u0000"+ + "\u1801\u1802\u0007\u0019\u0000\u0000\u1802\u1803\u0007\u0011\u0000\u0000"+ + "\u1803\u1804\u0007\u0007\u0000\u0000\u1804\u1805\u0007\u0011\u0000\u0000"+ + "\u1805\u1806\u0007\u0010\u0000\u0000\u1806\u1807\u0007\n\u0000\u0000\u1807"+ + "\u04ea\u0001\u0000\u0000\u0000\u1808\u1809\u0007\u001e\u0000\u0000\u1809"+ + "\u180a\u0007\u0016\u0000\u0000\u180a\u180b\u0007\t\u0000\u0000\u180b\u180c"+ + "\u0007\u0010\u0000\u0000\u180c\u180d\u0007\u0011\u0000\u0000\u180d\u180e"+ + "\u0007\u0019\u0000\u0000\u180e\u180f\u0007\b\u0000\u0000\u180f\u1810\u0005"+ + "_\u0000\u0000\u1810\u1811\u0007\f\u0000\u0000\u1811\u1812\u0007\u0005"+ + "\u0000\u0000\u1812\u1813\u0007\b\u0000\u0000\u1813\u1814\u0007\t\u0000"+ + "\u0000\u1814\u04ec\u0001\u0000\u0000\u0000\u1815\u1816\u0007\u001e\u0000"+ + "\u0000\u1816\u1817\u0007\u0016\u0000\u0000\u1817\u1818\u0007\t\u0000\u0000"+ + "\u1818\u1819\u0007\u0010\u0000\u0000\u1819\u181a\u0007\u0011\u0000\u0000"+ + "\u181a\u181b\u0007\u0019\u0000\u0000\u181b\u181c\u0007\b\u0000\u0000\u181c"+ + "\u181d\u0005_\u0000\u0000\u181d\u181e\u0007\u0014\u0000\u0000\u181e\u181f"+ + "\u0007\u0013\u0000\u0000\u181f\u1820\u0007\u0016\u0000\u0000\u1820\u1821"+ + "\u0007\r\u0000\u0000\u1821\u1822\u0007\t\u0000\u0000\u1822\u04ee\u0001"+ + "\u0000\u0000\u0000\u1823\u1824\u0007\u001e\u0000\u0000\u1824\u1825\u0007"+ + "\u0016\u0000\u0000\u1825\u1826\u0007\t\u0000\u0000\u1826\u1827\u0007\u0010"+ + "\u0000\u0000\u1827\u1828\u0007\u0011\u0000\u0000\u1828\u1829\u0007\u0019"+ + "\u0000\u0000\u1829\u182a\u0007\b\u0000\u0000\u182a\u182b\u0005_\u0000"+ + "\u0000\u182b\u182c\u0007\u0011\u0000\u0000\u182c\u182d\u0007\u0007\u0000"+ + "\u0000\u182d\u182e\u0007\u0010\u0000\u0000\u182e\u182f\u0007\n\u0000\u0000"+ + "\u182f\u1830\u0007\r\u0000\u0000\u1830\u1831\u0007\u001b\u0000\u0000\u1831"+ + "\u1832\u0007\u0005\u0000\u0000\u1832\u1833\u0007\u0006\u0000\u0000\u1833"+ + "\u04f0\u0001\u0000\u0000\u0000\u1834\u1835\u0007\u000f\u0000\u0000\u1835"+ + "\u1836\u0007\u0005\u0000\u0000\u1836\u1837\u0007\u0015\u0000\u0000\u1837"+ + "\u1838\u0007\n\u0000\u0000\u1838\u1839\u0005_\u0000\u0000\u1839\u183a"+ + "\u0007\f\u0000\u0000\u183a\u183b\u0007\u0005\u0000\u0000\u183b\u183c\u0007"+ + "\u0010\u0000\u0000\u183c\u183d\u0007\n\u0000\u0000\u183d\u04f2\u0001\u0000"+ + "\u0000\u0000\u183e\u183f\u0007\u000f\u0000\u0000\u183f\u1840\u0007\u0005"+ + "\u0000\u0000\u1840\u1841\u0007\u0015\u0000\u0000\u1841\u1842\u0007\n\u0000"+ + "\u0000\u1842\u1843\u0005_\u0000\u0000\u1843\u1844\u0007\u0011\u0000\u0000"+ + "\u1844\u1845\u0007\u0007\u0000\u0000\u1845\u1846\u0007\u0010\u0000\u0000"+ + "\u1846\u1847\u0007\n\u0000\u0000\u1847\u1848\u0007\r\u0000\u0000\u1848"+ + "\u1849\u0007\u001b\u0000\u0000\u1849\u184a\u0007\u0005\u0000\u0000\u184a"+ + "\u184b\u0007\u0006\u0000\u0000\u184b\u04f4\u0001\u0000\u0000\u0000\u184c"+ + "\u184d\u0007\u000f\u0000\u0000\u184d\u184e\u0007\u0005\u0000\u0000\u184e"+ + "\u184f\u0007\u0015\u0000\u0000\u184f\u1850\u0007\n\u0000\u0000\u1850\u1851"+ + "\u0005_\u0000\u0000\u1851\u1852\u0007\u0010\u0000\u0000\u1852\u1853\u0007"+ + "\u0011\u0000\u0000\u1853\u1854\u0007\u000f\u0000\u0000\u1854\u1855\u0007"+ + "\n\u0000\u0000\u1855\u04f6\u0001\u0000\u0000\u0000\u1856\u1857\u0007\u000f"+ + "\u0000\u0000\u1857\u1858\u0007\u0005\u0000\u0000\u1858\u1859\u0007\u0015"+ + "\u0000\u0000\u1859\u185a\u0007\n\u0000\u0000\u185a\u185b\u0005_\u0000"+ + "\u0000\u185b\u185c\u0007\u0010\u0000\u0000\u185c\u185d\u0007\u0011\u0000"+ + "\u0000\u185d\u185e\u0007\u000f\u0000\u0000\u185e\u185f\u0007\n\u0000\u0000"+ + "\u185f\u1860\u0007\t\u0000\u0000\u1860\u1861\u0007\u0010\u0000\u0000\u1861"+ + "\u1862\u0007\u0005\u0000\u0000\u1862\u1863\u0007\u000f\u0000\u0000\u1863"+ + "\u1864\u0007\u0018\u0000\u0000\u1864\u04f8\u0001\u0000\u0000\u0000\u1865"+ + "\u1866\u0007\u000f\u0000\u0000\u1866\u1867\u0007\u0005\u0000\u0000\u1867"+ + "\u1868\u0007\u0015\u0000\u0000\u1868\u1869\u0007\n\u0000\u0000\u1869\u186a"+ + "\u0005_\u0000\u0000\u186a\u186b\u0007\u0010\u0000\u0000\u186b\u186c\u0007"+ + "\u0011\u0000\u0000\u186c\u186d\u0007\u000f\u0000\u0000\u186d\u186e\u0007"+ + "\n\u0000\u0000\u186e\u186f\u0007\t\u0000\u0000\u186f\u1870\u0007\u0010"+ + "\u0000\u0000\u1870\u1871\u0007\u0005\u0000\u0000\u1871\u1872\u0007\u000f"+ + "\u0000\u0000\u1872\u1873\u0007\u0018\u0000\u0000\u1873\u1874\u0007\u0010"+ + "\u0000\u0000\u1874\u1875\u0007\u000b\u0000\u0000\u1875\u04fa\u0001\u0000"+ + "\u0000\u0000\u1876\u1877\u0007\u0007\u0000\u0000\u1877\u1878\u0007\u0013"+ + "\u0000\u0000\u1878\u1879\u0007\u001d\u0000\u0000\u1879\u04fc\u0001\u0000"+ + "\u0000\u0000\u187a\u187b\u0007\t\u0000\u0000\u187b\u187c\u0007\u0010\u0000"+ + "\u0000\u187c\u187d\u0007\u0005\u0000\u0000\u187d\u187e\u0007\u0010\u0000"+ + "\u0000\u187e\u187f\u0007\n\u0000\u0000\u187f\u1880\u0007\u000f\u0000\u0000"+ + "\u1880\u1881\u0007\n\u0000\u0000\u1881\u1882\u0007\u0007\u0000\u0000\u1882"+ + "\u1883\u0007\u0010\u0000\u0000\u1883\u1884\u0005_\u0000\u0000\u1884\u1885"+ + "\u0007\u0010\u0000\u0000\u1885\u1886\u0007\u0011\u0000\u0000\u1886\u1887"+ + "\u0007\u000f\u0000\u0000\u1887\u1888\u0007\n\u0000\u0000\u1888\u1889\u0007"+ + "\t\u0000\u0000\u1889\u188a\u0007\u0010\u0000\u0000\u188a\u188b\u0007\u0005"+ + "\u0000\u0000\u188b\u188c\u0007\u000f\u0000\u0000\u188c\u188d\u0007\u0018"+ + "\u0000\u0000\u188d\u04fe\u0001\u0000\u0000\u0000\u188e\u188f\u0007\u0010"+ + "\u0000\u0000\u188f\u1890\u0007\u0011\u0000\u0000\u1890\u1891\u0007\u000f"+ + "\u0000\u0000\u1891\u1892\u0007\n\u0000\u0000\u1892\u1893\u0007\u0013\u0000"+ + "\u0000\u1893\u1894\u0007\u0019\u0000\u0000\u1894\u1895\u0007\f\u0000\u0000"+ + "\u1895\u1896\u0007\u0005\u0000\u0000\u1896\u1897\u0007\b\u0000\u0000\u1897"+ + "\u0500\u0001\u0000\u0000\u0000\u1898\u1899\u0007\u0010\u0000\u0000\u1899"+ + "\u189a\u0007\r\u0000\u0000\u189a\u189b\u0007\u0005\u0000\u0000\u189b\u189c"+ + "\u0007\u0007\u0000\u0000\u189c\u189d\u0007\t\u0000\u0000\u189d\u189e\u0007"+ + "\u0005\u0000\u0000\u189e\u189f\u0007\u000e\u0000\u0000\u189f\u18a0\u0007"+ + "\u0010\u0000\u0000\u18a0\u18a1\u0007\u0011\u0000\u0000\u18a1\u18a2\u0007"+ + "\u0013\u0000\u0000\u18a2\u18a3\u0007\u0007\u0000\u0000\u18a3\u18a4\u0005"+ + "_\u0000\u0000\u18a4\u18a5\u0007\u0010\u0000\u0000\u18a5\u18a6\u0007\u0011"+ + "\u0000\u0000\u18a6\u18a7\u0007\u000f\u0000\u0000\u18a7\u18a8\u0007\n\u0000"+ + "\u0000\u18a8\u18a9\u0007\t\u0000\u0000\u18a9\u18aa\u0007\u0010\u0000\u0000"+ + "\u18aa\u18ab\u0007\u0005\u0000\u0000\u18ab\u18ac\u0007\u000f\u0000\u0000"+ + "\u18ac\u18ad\u0007\u0018\u0000\u0000\u18ad\u0502\u0001\u0000\u0000\u0000"+ + "\u18ae\u18af\u0007\u0010\u0000\u0000\u18af\u18b0\u0007\u0013\u0000\u0000"+ + "\u18b0\u18b1\u0005_\u0000\u0000\u18b1\u18b2\u0007\u0010\u0000\u0000\u18b2"+ + "\u18b3\u0007\u0011\u0000\u0000\u18b3\u18b4\u0007\u000f\u0000\u0000\u18b4"+ + "\u18b5\u0007\n\u0000\u0000\u18b5\u18b6\u0007\t\u0000\u0000\u18b6\u18b7"+ + "\u0007\u0010\u0000\u0000\u18b7\u18b8\u0007\u0005\u0000\u0000\u18b8\u18b9"+ + "\u0007\u000f\u0000\u0000\u18b9\u18ba\u0007\u0018\u0000\u0000\u18ba\u0504"+ + "\u0001\u0000\u0000\u0000\u18bb\u18bc\u0007\u0010\u0000\u0000\u18bc\u18bd"+ + "\u0007\u0013\u0000\u0000\u18bd\u18be\u0005_\u0000\u0000\u18be\u18bf\u0007"+ + "\u000e\u0000\u0000\u18bf\u18c0\u0007\u0014\u0000\u0000\u18c0\u18c1\u0007"+ + "\u0005\u0000\u0000\u18c1\u18c2\u0007\r\u0000\u0000\u18c2\u0506\u0001\u0000"+ + "\u0000\u0000\u18c3\u18c4\u0007\u0010\u0000\u0000\u18c4\u18c5\u0007\u0013"+ + "\u0000\u0000\u18c5\u18c6\u0005_\u0000\u0000\u18c6\u18c7\u0007\f\u0000"+ + "\u0000\u18c7\u18c8\u0007\u0005\u0000\u0000\u18c8\u18c9\u0007\u0010\u0000"+ + "\u0000\u18c9\u18ca\u0007\n\u0000\u0000\u18ca\u0508\u0001\u0000\u0000\u0000"+ + "\u18cb\u18cc\u0007\u0010\u0000\u0000\u18cc\u18cd\u0007\u0013\u0000\u0000"+ + "\u18cd\u18ce\u0005_\u0000\u0000\u18ce\u18cf\u0007\u0007\u0000\u0000\u18cf"+ + "\u18d0\u0007\u0016\u0000\u0000\u18d0\u18d1\u0007\u000f\u0000\u0000\u18d1"+ + "\u18d2\u0007\u0012\u0000\u0000\u18d2\u18d3\u0007\n\u0000\u0000\u18d3\u18d4"+ + "\u0007\r\u0000\u0000\u18d4\u050a\u0001\u0000\u0000\u0000\u18d5\u18d9\u0003"+ + "\u050d\u0284\u0000\u18d6\u18d8\u0003\u050f\u0285\u0000\u18d7\u18d6\u0001"+ + "\u0000\u0000\u0000\u18d8\u18db\u0001\u0000\u0000\u0000\u18d9\u18d7\u0001"+ + "\u0000\u0000\u0000\u18d9\u18da\u0001\u0000\u0000\u0000\u18da\u050c\u0001"+ + "\u0000\u0000\u0000\u18db\u18d9\u0001\u0000\u0000\u0000\u18dc\u18e3\u0007"+ + "\u001f\u0000\u0000\u18dd\u18de\u0007 \u0000\u0000\u18de\u18e3\u0004\u0284"+ + "\u0006\u0000\u18df\u18e0\u0007!\u0000\u0000\u18e0\u18e1\u0007\"\u0000"+ + "\u0000\u18e1\u18e3\u0004\u0284\u0007\u0000\u18e2\u18dc\u0001\u0000\u0000"+ + "\u0000\u18e2\u18dd\u0001\u0000\u0000\u0000\u18e2\u18df\u0001\u0000\u0000"+ + "\u0000\u18e3\u050e\u0001\u0000\u0000\u0000\u18e4\u18e7\u0003\u0511\u0286"+ + "\u0000\u18e5\u18e7\u0005$\u0000\u0000\u18e6\u18e4\u0001\u0000\u0000\u0000"+ + "\u18e6\u18e5\u0001\u0000\u0000\u0000\u18e7\u0510\u0001\u0000\u0000\u0000"+ + "\u18e8\u18eb\u0003\u050d\u0284\u0000\u18e9\u18eb\u0007\u0000\u0000\u0000"+ + "\u18ea\u18e8\u0001\u0000\u0000\u0000\u18ea\u18e9\u0001\u0000\u0000\u0000"+ + "\u18eb\u0512\u0001\u0000\u0000\u0000\u18ec\u18ed\u0003\u0515\u0288\u0000"+ + "\u18ed\u18ee\u0005\"\u0000\u0000\u18ee\u0514\u0001\u0000\u0000\u0000\u18ef"+ + "\u18f5\u0005\"\u0000\u0000\u18f0\u18f1\u0005\"\u0000\u0000\u18f1\u18f4"+ + "\u0005\"\u0000\u0000\u18f2\u18f4\b#\u0000\u0000\u18f3\u18f0\u0001\u0000"+ + "\u0000\u0000\u18f3\u18f2\u0001\u0000\u0000\u0000\u18f4\u18f7\u0001\u0000"+ + "\u0000\u0000\u18f5\u18f3\u0001\u0000\u0000\u0000\u18f5\u18f6\u0001\u0000"+ + "\u0000\u0000\u18f6\u0516\u0001\u0000\u0000\u0000\u18f7\u18f5\u0001\u0000"+ + "\u0000\u0000\u18f8\u18f9\u0003\u0519\u028a\u0000\u18f9\u18fa\u0005\"\u0000"+ + "\u0000\u18fa\u0518\u0001\u0000\u0000\u0000\u18fb\u1901\u0005\"\u0000\u0000"+ + "\u18fc\u18fd\u0005\"\u0000\u0000\u18fd\u1900\u0005\"\u0000\u0000\u18fe"+ + "\u1900\b$\u0000\u0000\u18ff\u18fc\u0001\u0000\u0000\u0000\u18ff\u18fe"+ + "\u0001\u0000\u0000\u0000\u1900\u1903\u0001\u0000\u0000\u0000\u1901\u18ff"+ + "\u0001\u0000\u0000\u0000\u1901\u1902\u0001\u0000\u0000\u0000\u1902\u051a"+ + "\u0001\u0000\u0000\u0000\u1903\u1901\u0001\u0000\u0000\u0000\u1904\u1905"+ + "\u0007\u0016\u0000\u0000\u1905\u1906\u0005&\u0000\u0000\u1906\u1907\u0003"+ + "\u0513\u0287\u0000\u1907\u051c\u0001\u0000\u0000\u0000\u1908\u1909\u0007"+ + "\u0016\u0000\u0000\u1909\u190a\u0005&\u0000\u0000\u190a\u190b\u0003\u0515"+ + "\u0288\u0000\u190b\u051e\u0001\u0000\u0000\u0000\u190c\u190d\u0007\u0016"+ + "\u0000\u0000\u190d\u190e\u0005&\u0000\u0000\u190e\u190f\u0003\u0517\u0289"+ + "\u0000\u190f\u0520\u0001\u0000\u0000\u0000\u1910\u1911\u0007\u0016\u0000"+ + "\u0000\u1911\u1912\u0005&\u0000\u0000\u1912\u1913\u0003\u0519\u028a\u0000"+ + "\u1913\u0522\u0001\u0000\u0000\u0000\u1914\u1915\u0003\u0525\u0290\u0000"+ + "\u1915\u1916\u0005\'\u0000\u0000\u1916\u0524\u0001\u0000\u0000\u0000\u1917"+ + "\u1922\u0005\'\u0000\u0000\u1918\u1919\u0005\'\u0000\u0000\u1919\u1921"+ + "\u0005\'\u0000\u0000\u191a\u1921\b%\u0000\u0000\u191b\u191c\u0005\\\u0000"+ + "\u0000\u191c\u191d\u0005\\\u0000\u0000\u191d\u1921\u0005\'\u0000\u0000"+ + "\u191e\u191f\u0005\\\u0000\u0000\u191f\u1921\u0005\'\u0000\u0000\u1920"+ + "\u1918\u0001\u0000\u0000\u0000\u1920\u191a\u0001\u0000\u0000\u0000\u1920"+ + "\u191b\u0001\u0000\u0000\u0000\u1920\u191e\u0001\u0000\u0000\u0000\u1921"+ + "\u1924\u0001\u0000\u0000\u0000\u1922\u1920\u0001\u0000\u0000\u0000\u1922"+ + "\u1923\u0001\u0000\u0000\u0000\u1923\u0526\u0001\u0000\u0000\u0000\u1924"+ + "\u1922\u0001\u0000\u0000\u0000\u1925\u1926\u0007\n\u0000\u0000\u1926\u1927"+ + "\u0005\'\u0000\u0000\u1927\u1928\u0001\u0000\u0000\u0000\u1928\u1929\u0006"+ + "\u0291\u0002\u0000\u1929\u192a\u0006\u0291\u0003\u0000\u192a\u0528\u0001"+ + "\u0000\u0000\u0000\u192b\u192c\u0003\u052b\u0293\u0000\u192c\u192d\u0005"+ + "\'\u0000\u0000\u192d\u052a\u0001\u0000\u0000\u0000\u192e\u192f\u0007\u0016"+ + "\u0000\u0000\u192f\u1930\u0005&\u0000\u0000\u1930\u1931\u0003\u0525\u0290"+ + "\u0000\u1931\u052c\u0001\u0000\u0000\u0000\u1932\u1934\u0005$\u0000\u0000"+ + "\u1933\u1935\u0003\u052f\u0295\u0000\u1934\u1933\u0001\u0000\u0000\u0000"+ + "\u1934\u1935\u0001\u0000\u0000\u0000\u1935\u1936\u0001\u0000\u0000\u0000"+ + "\u1936\u1937\u0005$\u0000\u0000\u1937\u1938\u0006\u0294\u0004\u0000\u1938"+ + "\u1939\u0001\u0000\u0000\u0000\u1939\u193a\u0006\u0294\u0005\u0000\u193a"+ + "\u052e\u0001\u0000\u0000\u0000\u193b\u193f\u0003\u050d\u0284\u0000\u193c"+ + "\u193e\u0003\u0511\u0286\u0000\u193d\u193c\u0001\u0000\u0000\u0000\u193e"+ + "\u1941\u0001\u0000\u0000\u0000\u193f\u193d\u0001\u0000\u0000\u0000\u193f"+ + "\u1940\u0001\u0000\u0000\u0000\u1940\u0530\u0001\u0000\u0000\u0000\u1941"+ + "\u193f\u0001\u0000\u0000\u0000\u1942\u1943\u0003\u0533\u0297\u0000\u1943"+ + "\u1944\u0005\'\u0000\u0000\u1944\u0532\u0001\u0000\u0000\u0000\u1945\u1946"+ + "\u0007\u0012\u0000\u0000\u1946\u194a\u0005\'\u0000\u0000\u1947\u1949\u0007"+ + "&\u0000\u0000\u1948\u1947\u0001\u0000\u0000\u0000\u1949\u194c\u0001\u0000"+ + "\u0000\u0000\u194a\u1948\u0001\u0000\u0000\u0000\u194a\u194b\u0001\u0000"+ + "\u0000\u0000\u194b\u0534\u0001\u0000\u0000\u0000\u194c\u194a\u0001\u0000"+ + "\u0000\u0000\u194d\u194e\u0003\u0537\u0299\u0000\u194e\u194f\u0005\'\u0000"+ + "\u0000\u194f\u0536\u0001\u0000\u0000\u0000\u1950\u1951\u0007\u0012\u0000"+ + "\u0000\u1951\u1952\u0003\u0525\u0290\u0000\u1952\u0538\u0001\u0000\u0000"+ + "\u0000\u1953\u1954\u0003\u053b\u029b\u0000\u1954\u1955\u0005\'\u0000\u0000"+ + "\u1955\u053a\u0001\u0000\u0000\u0000\u1956\u1957\u0007\u001a\u0000\u0000"+ + "\u1957\u195b\u0005\'\u0000\u0000\u1958\u195a\u0007\'\u0000\u0000\u1959"+ + "\u1958\u0001\u0000\u0000\u0000\u195a\u195d\u0001\u0000\u0000\u0000\u195b"+ + "\u1959\u0001\u0000\u0000\u0000\u195b\u195c\u0001\u0000\u0000\u0000\u195c"+ + "\u053c\u0001\u0000\u0000\u0000\u195d\u195b\u0001\u0000\u0000\u0000\u195e"+ + "\u195f\u0003\u053f\u029d\u0000\u195f\u1960\u0005\'\u0000\u0000\u1960\u053e"+ + "\u0001\u0000\u0000\u0000\u1961\u1962\u0007\u001a\u0000\u0000\u1962\u1963"+ + "\u0003\u0525\u0290\u0000\u1963\u0540\u0001\u0000\u0000\u0000\u1964\u1965"+ + "\u0003\u0547\u02a1\u0000\u1965\u0542\u0001\u0000\u0000\u0000\u1966\u1967"+ + "\u0003\u0547\u02a1\u0000\u1967\u1968\u0005.\u0000\u0000\u1968\u1969\u0005"+ + ".\u0000\u0000\u1969\u196a\u0001\u0000\u0000\u0000\u196a\u196b\u0006\u029f"+ + "\u0006\u0000\u196b\u0544\u0001\u0000\u0000\u0000\u196c\u196d\u0003\u0547"+ + "\u02a1\u0000\u196d\u196f\u0005.\u0000\u0000\u196e\u1970\u0003\u0547\u02a1"+ + "\u0000\u196f\u196e\u0001\u0000\u0000\u0000\u196f\u1970\u0001\u0000\u0000"+ + "\u0000\u1970\u1976\u0001\u0000\u0000\u0000\u1971\u1973\u0007\n\u0000\u0000"+ + "\u1972\u1974\u0007\u0001\u0000\u0000\u1973\u1972\u0001\u0000\u0000\u0000"+ + "\u1973\u1974\u0001\u0000\u0000\u0000\u1974\u1975\u0001\u0000\u0000\u0000"+ + "\u1975\u1977\u0003\u0547\u02a1\u0000\u1976\u1971\u0001\u0000\u0000\u0000"+ + "\u1976\u1977\u0001\u0000\u0000\u0000\u1977\u1989\u0001\u0000\u0000\u0000"+ + "\u1978\u1979\u0005.\u0000\u0000\u1979\u197f\u0003\u0547\u02a1\u0000\u197a"+ + "\u197c\u0007\n\u0000\u0000\u197b\u197d\u0007\u0001\u0000\u0000\u197c\u197b"+ + "\u0001\u0000\u0000\u0000\u197c\u197d\u0001\u0000\u0000\u0000\u197d\u197e"+ + "\u0001\u0000\u0000\u0000\u197e\u1980\u0003\u0547\u02a1\u0000\u197f\u197a"+ + "\u0001\u0000\u0000\u0000\u197f\u1980\u0001\u0000\u0000\u0000\u1980\u1989"+ + "\u0001\u0000\u0000\u0000\u1981\u1982\u0003\u0547\u02a1\u0000\u1982\u1984"+ + "\u0007\n\u0000\u0000\u1983\u1985\u0007\u0001\u0000\u0000\u1984\u1983\u0001"+ + "\u0000\u0000\u0000\u1984\u1985\u0001\u0000\u0000\u0000\u1985\u1986\u0001"+ + "\u0000\u0000\u0000\u1986\u1987\u0003\u0547\u02a1\u0000\u1987\u1989\u0001"+ + "\u0000\u0000\u0000\u1988\u196c\u0001\u0000\u0000\u0000\u1988\u1978\u0001"+ + "\u0000\u0000\u0000\u1988\u1981\u0001\u0000\u0000\u0000\u1989\u0546\u0001"+ + "\u0000\u0000\u0000\u198a\u198c\u0007\u0000\u0000\u0000\u198b\u198a\u0001"+ + "\u0000\u0000\u0000\u198c\u198d\u0001\u0000\u0000\u0000\u198d\u198b\u0001"+ + "\u0000\u0000\u0000\u198d\u198e\u0001\u0000\u0000\u0000\u198e\u0548\u0001"+ + "\u0000\u0000\u0000\u198f\u1990\u0005:\u0000\u0000\u1990\u1991\u0005\""+ + "\u0000\u0000\u1991\u1999\u0001\u0000\u0000\u0000\u1992\u1993\u0005\\\u0000"+ + "\u0000\u1993\u1998\t\u0000\u0000\u0000\u1994\u1995\u0005\"\u0000\u0000"+ + "\u1995\u1998\u0005\"\u0000\u0000\u1996\u1998\b(\u0000\u0000\u1997\u1992"+ + "\u0001\u0000\u0000\u0000\u1997\u1994\u0001\u0000\u0000\u0000\u1997\u1996"+ + "\u0001\u0000\u0000\u0000\u1998\u199b\u0001\u0000\u0000\u0000\u1999\u1997"+ + "\u0001\u0000\u0000\u0000\u1999\u199a\u0001\u0000\u0000\u0000\u199a\u199c"+ + "\u0001\u0000\u0000\u0000\u199b\u1999\u0001\u0000\u0000\u0000\u199c\u199d"+ + "\u0005\"\u0000\u0000\u199d\u054a\u0001\u0000\u0000\u0000\u199e\u19a0\u0007"+ + ")\u0000\u0000\u199f\u199e\u0001\u0000\u0000\u0000\u19a0\u19a1\u0001\u0000"+ + "\u0000\u0000\u19a1\u199f\u0001\u0000\u0000\u0000\u19a1\u19a2\u0001\u0000"+ + "\u0000\u0000\u19a2\u19a3\u0001\u0000\u0000\u0000\u19a3\u19a4\u0006\u02a3"+ + "\u0007\u0000\u19a4\u054c\u0001\u0000\u0000\u0000\u19a5\u19a7\u0005\r\u0000"+ + "\u0000\u19a6\u19a8\u0005\n\u0000\u0000\u19a7\u19a6\u0001\u0000\u0000\u0000"+ + "\u19a7\u19a8\u0001\u0000\u0000\u0000\u19a8\u19ab\u0001\u0000\u0000\u0000"+ + "\u19a9\u19ab\u0005\n\u0000\u0000\u19aa\u19a5\u0001\u0000\u0000\u0000\u19aa"+ + "\u19a9\u0001\u0000\u0000\u0000\u19ab\u19ac\u0001\u0000\u0000\u0000\u19ac"+ + "\u19ad\u0006\u02a4\u0007\u0000\u19ad\u054e\u0001\u0000\u0000\u0000\u19ae"+ + "\u19af\u0005-\u0000\u0000\u19af\u19b0\u0005-\u0000\u0000\u19b0\u19b4\u0001"+ + "\u0000\u0000\u0000\u19b1\u19b3\b*\u0000\u0000\u19b2\u19b1\u0001\u0000"+ + "\u0000\u0000\u19b3\u19b6\u0001\u0000\u0000\u0000\u19b4\u19b2\u0001\u0000"+ + "\u0000\u0000\u19b4\u19b5\u0001\u0000\u0000\u0000\u19b5\u19b7\u0001\u0000"+ + "\u0000\u0000\u19b6\u19b4\u0001\u0000\u0000\u0000\u19b7\u19b8\u0006\u02a5"+ + "\u0007\u0000\u19b8\u0550\u0001\u0000\u0000\u0000\u19b9\u19ba\u0005/\u0000"+ + "\u0000\u19ba\u19bb\u0005*\u0000\u0000\u19bb\u19d2\u0001\u0000\u0000\u0000"+ + "\u19bc\u19be\u0005/\u0000\u0000\u19bd\u19bc\u0001\u0000\u0000\u0000\u19be"+ + "\u19c1\u0001\u0000\u0000\u0000\u19bf\u19bd\u0001\u0000\u0000\u0000\u19bf"+ + "\u19c0\u0001\u0000\u0000\u0000\u19c0\u19c2\u0001\u0000\u0000\u0000\u19c1"+ + "\u19bf\u0001\u0000\u0000\u0000\u19c2\u19d1\u0003\u0551\u02a6\u0000\u19c3"+ + "\u19d1\b+\u0000\u0000\u19c4\u19c6\u0005/\u0000\u0000\u19c5\u19c4\u0001"+ + "\u0000\u0000\u0000\u19c6\u19c7\u0001\u0000\u0000\u0000\u19c7\u19c5\u0001"+ + "\u0000\u0000\u0000\u19c7\u19c8\u0001\u0000\u0000\u0000\u19c8\u19c9\u0001"+ + "\u0000\u0000\u0000\u19c9\u19d1\b+\u0000\u0000\u19ca\u19cc\u0005*\u0000"+ + "\u0000\u19cb\u19ca\u0001\u0000\u0000\u0000\u19cc\u19cd\u0001\u0000\u0000"+ + "\u0000\u19cd\u19cb\u0001\u0000\u0000\u0000\u19cd\u19ce\u0001\u0000\u0000"+ + "\u0000\u19ce\u19cf\u0001\u0000\u0000\u0000\u19cf\u19d1\b+\u0000\u0000"+ + "\u19d0\u19bf\u0001\u0000\u0000\u0000\u19d0\u19c3\u0001\u0000\u0000\u0000"+ + "\u19d0\u19c5\u0001\u0000\u0000\u0000\u19d0\u19cb\u0001\u0000\u0000\u0000"+ + "\u19d1\u19d4\u0001\u0000\u0000\u0000\u19d2\u19d0\u0001\u0000\u0000\u0000"+ + "\u19d2\u19d3\u0001\u0000\u0000\u0000\u19d3\u19d8\u0001\u0000\u0000\u0000"+ + "\u19d4\u19d2\u0001\u0000\u0000\u0000\u19d5\u19d7\u0005*\u0000\u0000\u19d6"+ + "\u19d5\u0001\u0000\u0000\u0000\u19d7\u19da\u0001\u0000\u0000\u0000\u19d8"+ + "\u19d6\u0001\u0000\u0000\u0000\u19d8\u19d9\u0001\u0000\u0000\u0000\u19d9"+ + "\u19db\u0001\u0000\u0000\u0000\u19da\u19d8\u0001\u0000\u0000\u0000\u19db"+ + "\u19dc\u0005*\u0000\u0000\u19dc\u19dd\u0005/\u0000\u0000\u19dd\u19de\u0001"+ + "\u0000\u0000\u0000\u19de\u19df\u0006\u02a6\u0007\u0000\u19df\u0552\u0001"+ + "\u0000\u0000\u0000\u19e0\u19e1\u0005/\u0000\u0000\u19e1\u19e2\u0005*\u0000"+ + "\u0000\u19e2\u19fb\u0001\u0000\u0000\u0000\u19e3\u19e5\u0005/\u0000\u0000"+ + "\u19e4\u19e3\u0001\u0000\u0000\u0000\u19e5\u19e8\u0001\u0000\u0000\u0000"+ + "\u19e6\u19e4\u0001\u0000\u0000\u0000\u19e6\u19e7\u0001\u0000\u0000\u0000"+ + "\u19e7\u19e9\u0001\u0000\u0000\u0000\u19e8\u19e6\u0001\u0000\u0000\u0000"+ + "\u19e9\u19fa\u0003\u0551\u02a6\u0000\u19ea\u19fa\b+\u0000\u0000\u19eb"+ + "\u19ed\u0005/\u0000\u0000\u19ec\u19eb\u0001\u0000\u0000\u0000\u19ed\u19ee"+ + "\u0001\u0000\u0000\u0000\u19ee\u19ec\u0001\u0000\u0000\u0000\u19ee\u19ef"+ + "\u0001\u0000\u0000\u0000\u19ef\u19f0\u0001\u0000\u0000\u0000\u19f0\u19f8"+ + "\b+\u0000\u0000\u19f1\u19f3\u0005*\u0000\u0000\u19f2\u19f1\u0001\u0000"+ + "\u0000\u0000\u19f3\u19f4\u0001\u0000\u0000\u0000\u19f4\u19f2\u0001\u0000"+ + "\u0000\u0000\u19f4\u19f5\u0001\u0000\u0000\u0000\u19f5\u19f6\u0001\u0000"+ + "\u0000\u0000\u19f6\u19f8\b+\u0000\u0000\u19f7\u19ec\u0001\u0000\u0000"+ + "\u0000\u19f7\u19f2\u0001\u0000\u0000\u0000\u19f8\u19fa\u0001\u0000\u0000"+ + "\u0000\u19f9\u19e6\u0001\u0000\u0000\u0000\u19f9\u19ea\u0001\u0000\u0000"+ + "\u0000\u19f9\u19f7\u0001\u0000\u0000\u0000\u19fa\u19fd\u0001\u0000\u0000"+ + "\u0000\u19fb\u19f9\u0001\u0000\u0000\u0000\u19fb\u19fc\u0001\u0000\u0000"+ + "\u0000\u19fc\u1a0f\u0001\u0000\u0000\u0000\u19fd\u19fb\u0001\u0000\u0000"+ + "\u0000\u19fe\u1a00\u0005/\u0000\u0000\u19ff\u19fe\u0001\u0000\u0000\u0000"+ + "\u1a00\u1a01\u0001\u0000\u0000\u0000\u1a01\u19ff\u0001\u0000\u0000\u0000"+ + "\u1a01\u1a02\u0001\u0000\u0000\u0000\u1a02\u1a10\u0001\u0000\u0000\u0000"+ + "\u1a03\u1a05\u0005*\u0000\u0000\u1a04\u1a03\u0001\u0000\u0000\u0000\u1a05"+ + "\u1a06\u0001\u0000\u0000\u0000\u1a06\u1a04\u0001\u0000\u0000\u0000\u1a06"+ + "\u1a07\u0001\u0000\u0000\u0000\u1a07\u1a10\u0001\u0000\u0000\u0000\u1a08"+ + "\u1a0a\u0005/\u0000\u0000\u1a09\u1a08\u0001\u0000\u0000\u0000\u1a0a\u1a0d"+ + "\u0001\u0000\u0000\u0000\u1a0b\u1a09\u0001\u0000\u0000\u0000\u1a0b\u1a0c"+ + "\u0001\u0000\u0000\u0000\u1a0c\u1a0e\u0001\u0000\u0000\u0000\u1a0d\u1a0b"+ + "\u0001\u0000\u0000\u0000\u1a0e\u1a10\u0003\u0553\u02a7\u0000\u1a0f\u19ff"+ + "\u0001\u0000\u0000\u0000\u1a0f\u1a04\u0001\u0000\u0000\u0000\u1a0f\u1a0b"+ + "\u0001\u0000\u0000\u0000\u1a0f\u1a10\u0001\u0000\u0000\u0000\u1a10\u1a11"+ + "\u0001\u0000\u0000\u0000\u1a11\u1a12\u0006\u02a7\b\u0000\u1a12\u0554\u0001"+ + "\u0000\u0000\u0000\u1a13\u1a1f\u0005\\\u0000\u0000\u1a14\u1a1e\b,\u0000"+ + "\u0000\u1a15\u1a19\u0005\"\u0000\u0000\u1a16\u1a18\b-\u0000\u0000\u1a17"+ + "\u1a16\u0001\u0000\u0000\u0000\u1a18\u1a1b\u0001\u0000\u0000\u0000\u1a19"+ + "\u1a17\u0001\u0000\u0000\u0000\u1a19\u1a1a\u0001\u0000\u0000\u0000\u1a1a"+ + "\u1a1c\u0001\u0000\u0000\u0000\u1a1b\u1a19\u0001\u0000\u0000\u0000\u1a1c"+ + "\u1a1e\u0005\"\u0000\u0000\u1a1d\u1a14\u0001\u0000\u0000\u0000\u1a1d\u1a15"+ + "\u0001\u0000\u0000\u0000\u1a1e\u1a21\u0001\u0000\u0000\u0000\u1a1f\u1a1d"+ + "\u0001\u0000\u0000\u0000\u1a1f\u1a20\u0001\u0000\u0000\u0000\u1a20\u1a29"+ + "\u0001\u0000\u0000\u0000\u1a21\u1a1f\u0001\u0000\u0000\u0000\u1a22\u1a26"+ + "\u0005\"\u0000\u0000\u1a23\u1a25\b-\u0000\u0000\u1a24\u1a23\u0001\u0000"+ + "\u0000\u0000\u1a25\u1a28\u0001\u0000\u0000\u0000\u1a26\u1a24\u0001\u0000"+ + "\u0000\u0000\u1a26\u1a27\u0001\u0000\u0000\u0000\u1a27\u1a2a\u0001\u0000"+ + "\u0000\u0000\u1a28\u1a26\u0001\u0000\u0000\u0000\u1a29\u1a22\u0001\u0000"+ + "\u0000\u0000\u1a29\u1a2a\u0001\u0000\u0000\u0000\u1a2a\u0556\u0001\u0000"+ + "\u0000\u0000\u1a2b\u1a2c\u0005\\\u0000\u0000\u1a2c\u1a2d\u0005\\\u0000"+ + "\u0000\u1a2d\u0558\u0001\u0000\u0000\u0000\u1a2e\u1a2f\t\u0000\u0000\u0000"+ + "\u1a2f\u055a\u0001\u0000\u0000\u0000\u1a30\u1a31\u0003\u055f\u02ad\u0000"+ + "\u1a31\u1a32\u0005\'\u0000\u0000\u1a32\u1a33\u0001\u0000\u0000\u0000\u1a33"+ + "\u1a34\u0006\u02ab\t\u0000\u1a34\u055c\u0001\u0000\u0000\u0000\u1a35\u1a37"+ + "\u0003\u055f\u02ad\u0000\u1a36\u1a38\u0005\\\u0000\u0000\u1a37\u1a36\u0001"+ + "\u0000\u0000\u0000\u1a37\u1a38\u0001\u0000\u0000\u0000\u1a38\u1a39\u0001"+ + "\u0000\u0000\u0000\u1a39\u1a3a\u0005\u0000\u0000\u0001\u1a3a\u055e\u0001"+ + "\u0000\u0000\u0000\u1a3b\u1a3c\u0005\\\u0000\u0000\u1a3c\u1a56\u0005\'"+ + "\u0000\u0000\u1a3d\u1a3e\u0005\'\u0000\u0000\u1a3e\u1a3f\u0005\'\u0000"+ + "\u0000\u1a3f\u1a56\u0005\'\u0000\u0000\u1a40\u1a52\u0005\\\u0000\u0000"+ + "\u1a41\u1a42\u0005x\u0000\u0000\u1a42\u1a53\u0007\'\u0000\u0000\u1a43"+ + "\u1a44\u0005u\u0000\u0000\u1a44\u1a45\u0007\'\u0000\u0000\u1a45\u1a46"+ + "\u0007\'\u0000\u0000\u1a46\u1a47\u0007\'\u0000\u0000\u1a47\u1a53\u0007"+ + "\'\u0000\u0000\u1a48\u1a49\u0005U\u0000\u0000\u1a49\u1a4a\u0007\'\u0000"+ + "\u0000\u1a4a\u1a4b\u0007\'\u0000\u0000\u1a4b\u1a4c\u0007\'\u0000\u0000"+ + "\u1a4c\u1a4d\u0007\'\u0000\u0000\u1a4d\u1a4e\u0007\'\u0000\u0000\u1a4e"+ + "\u1a4f\u0007\'\u0000\u0000\u1a4f\u1a50\u0007\'\u0000\u0000\u1a50\u1a53"+ + "\u0007\'\u0000\u0000\u1a51\u1a53\b.\u0000\u0000\u1a52\u1a41\u0001\u0000"+ + "\u0000\u0000\u1a52\u1a43\u0001\u0000\u0000\u0000\u1a52\u1a48\u0001\u0000"+ + "\u0000\u0000\u1a52\u1a51\u0001\u0000\u0000\u0000\u1a53\u1a56\u0001\u0000"+ + "\u0000\u0000\u1a54\u1a56\b/\u0000\u0000\u1a55\u1a3b\u0001\u0000\u0000"+ + "\u0000\u1a55\u1a3d\u0001\u0000\u0000\u0000\u1a55\u1a40\u0001\u0000\u0000"+ + "\u0000\u1a55\u1a54\u0001\u0000\u0000\u0000\u1a56\u1a59\u0001\u0000\u0000"+ + "\u0000\u1a57\u1a55\u0001\u0000\u0000\u0000\u1a57\u1a58\u0001\u0000\u0000"+ + "\u0000\u1a58\u0560\u0001\u0000\u0000\u0000\u1a59\u1a57\u0001\u0000\u0000"+ + "\u0000\u1a5a\u1a5b\u0003\u0565\u02b0\u0000\u1a5b\u1a5c\u0005\'\u0000\u0000"+ + "\u1a5c\u1a5d\u0001\u0000\u0000\u0000\u1a5d\u1a5e\u0006\u02ae\t\u0000\u1a5e"+ + "\u0562\u0001\u0000\u0000\u0000\u1a5f\u1a61\u0003\u0565\u02b0\u0000\u1a60"+ + "\u1a62\u0005\\\u0000\u0000\u1a61\u1a60\u0001\u0000\u0000\u0000\u1a61\u1a62"+ + "\u0001\u0000\u0000\u0000\u1a62\u1a63\u0001\u0000\u0000\u0000\u1a63\u1a64"+ + "\u0005\u0000\u0000\u0001\u1a64\u0564\u0001\u0000\u0000\u0000\u1a65\u1a66"+ + "\u0005\'\u0000\u0000\u1a66\u1a6b\u0005\'\u0000\u0000\u1a67\u1a68\u0005"+ + "\\\u0000\u0000\u1a68\u1a6b\t\u0000\u0000\u0000\u1a69\u1a6b\b/\u0000\u0000"+ + "\u1a6a\u1a65\u0001\u0000\u0000\u0000\u1a6a\u1a67\u0001\u0000\u0000\u0000"+ + "\u1a6a\u1a69\u0001\u0000\u0000\u0000\u1a6b\u1a6e\u0001\u0000\u0000\u0000"+ + "\u1a6c\u1a6a\u0001\u0000\u0000\u0000\u1a6c\u1a6d\u0001\u0000\u0000\u0000"+ + "\u1a6d\u0566\u0001\u0000\u0000\u0000\u1a6e\u1a6c\u0001\u0000\u0000\u0000"+ + "\u1a6f\u1a70\u0003\u054b\u02a3\u0000\u1a70\u1a71\u0001\u0000\u0000\u0000"+ + "\u1a71\u1a72\u0006\u02b1\n\u0000\u1a72\u1a73\u0006\u02b1\u0007\u0000\u1a73"+ + "\u0568\u0001\u0000\u0000\u0000\u1a74\u1a75\u0003\u054d\u02a4\u0000\u1a75"+ + "\u1a76\u0001\u0000\u0000\u0000\u1a76\u1a77\u0006\u02b2\u000b\u0000\u1a77"+ + "\u1a78\u0006\u02b2\u0007\u0000\u1a78\u1a79\u0006\u02b2\f\u0000\u1a79\u056a"+ + "\u0001\u0000\u0000\u0000\u1a7a\u1a7b\u0003\u054b\u02a3\u0000\u1a7b\u1a7c"+ + "\u0001\u0000\u0000\u0000\u1a7c\u1a7d\u0006\u02b3\n\u0000\u1a7d\u1a7e\u0006"+ + "\u02b3\u0007\u0000\u1a7e\u056c\u0001\u0000\u0000\u0000\u1a7f\u1a80\u0003"+ + "\u054d\u02a4\u0000\u1a80\u1a81\u0001\u0000\u0000\u0000\u1a81\u1a82\u0006"+ + "\u02b4\u000b\u0000\u1a82\u1a83\u0006\u02b4\u0007\u0000\u1a83\u056e\u0001"+ + "\u0000\u0000\u0000\u1a84\u1a85\u0005\'\u0000\u0000\u1a85\u1a86\u0001\u0000"+ + "\u0000\u0000\u1a86\u1a87\u0006\u02b5\u0002\u0000\u1a87\u1a88\u0006\u02b5"+ + "\r\u0000\u1a88\u0570\u0001\u0000\u0000\u0000\u1a89\u1a8b\b0\u0000\u0000"+ + "\u1a8a\u1a89\u0001\u0000\u0000\u0000\u1a8b\u1a8c\u0001\u0000\u0000\u0000"+ + "\u1a8c\u1a8a\u0001\u0000\u0000\u0000\u1a8c\u1a8d\u0001\u0000\u0000\u0000"+ + "\u1a8d\u1a96\u0001\u0000\u0000\u0000\u1a8e\u1a92\u0005$\u0000\u0000\u1a8f"+ + "\u1a91\b0\u0000\u0000\u1a90\u1a8f\u0001\u0000\u0000\u0000\u1a91\u1a94"+ + "\u0001\u0000\u0000\u0000\u1a92\u1a90\u0001\u0000\u0000\u0000\u1a92\u1a93"+ + "\u0001\u0000\u0000\u0000\u1a93\u1a96\u0001\u0000\u0000\u0000\u1a94\u1a92"+ + "\u0001\u0000\u0000\u0000\u1a95\u1a8a\u0001\u0000\u0000\u0000\u1a95\u1a8e"+ + "\u0001\u0000\u0000\u0000\u1a96\u0572\u0001\u0000\u0000\u0000\u1a97\u1a99"+ + "\u0005$\u0000\u0000\u1a98\u1a9a\u0003\u052f\u0295\u0000\u1a99\u1a98\u0001"+ + "\u0000\u0000\u0000\u1a99\u1a9a\u0001\u0000\u0000\u0000\u1a9a\u1a9b\u0001"+ + "\u0000\u0000\u0000\u1a9b\u1a9c\u0005$\u0000\u0000\u1a9c\u1a9d\u0001\u0000"+ + "\u0000\u0000\u1a9d\u1a9e\u0004\u02b7\b\u0000\u1a9e\u1a9f\u0006\u02b7\u000e"+ + "\u0000\u1a9f\u1aa0\u0001\u0000\u0000\u0000\u1aa0\u1aa1\u0006\u02b7\u000f"+ + "\u0000\u1aa1\u0574\u0001\u0000\u0000\u0000O\u0000\u0001\u0002\u0003\u0004"+ + "\u057e\u05c6\u05cc\u05ce\u05d3\u05d7\u05d9\u05eb\u05ed\u05f6\u05f8\u05fd"+ + "\u0602\u0604\u18d9\u18e2\u18e6\u18ea\u18f3\u18f5\u18ff\u1901\u1920\u1922"+ + "\u1934\u193f\u194a\u195b\u196f\u1973\u1976\u197c\u197f\u1984\u1988\u198d"+ + "\u1997\u1999\u19a1\u19a7\u19aa\u19b4\u19bf\u19c7\u19cd\u19d0\u19d2\u19d8"+ + "\u19e6\u19ee\u19f4\u19f7\u19f9\u19fb\u1a01\u1a06\u1a0b\u1a0f\u1a19\u1a1d"+ + "\u1a1f\u1a26\u1a29\u1a37\u1a52\u1a55\u1a57\u1a61\u1a6a\u1a6c\u1a8c\u1a92"+ + "\u1a95\u1a99\u0010\u0001\u001f\u0000\u0007\u001f\u0000\u0003\u0000\u0000"+ + "\u0005\u0001\u0000\u0001\u0294\u0001\u0005\u0004\u0000\u0001\u029f\u0002"+ + "\u0000\u0001\u0000\u0001\u02a7\u0003\u0002\u0002\u0000\u0007\u0299\u0000"+ + "\u0007\u029a\u0000\u0002\u0003\u0000\u0002\u0001\u0000\u0001\u02b7\u0004"+ + "\u0004\u0000\u0000"; public static final String _serializedATN = Utils.join( new String[] { _serializedATNSegment0, _serializedATNSegment1, - _serializedATNSegment2, - _serializedATNSegment3 + _serializedATNSegment2 }, "" ); diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexerBase.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexerBase.java new file mode 100644 index 000000000..2148ee447 --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexerBase.java @@ -0,0 +1,82 @@ +/* +PostgreSQL grammar. +The MIT License (MIT). +Copyright (c) 2021-2023, Oleksii Kovalov (Oleksii.Kovalov@outlook.com). +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ +package org.springframework.ide.vscode.parser.postgresql; + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Lexer; + +import java.util.ArrayDeque; +import java.util.Deque; + +public abstract class PostgreSqlLexerBase extends Lexer { + protected final Deque tags = new ArrayDeque<>(); + + protected PostgreSqlLexerBase(CharStream input) { + super(input); + + } + + public void pushTag() { + tags.push(getText()); + } + + public boolean isTag() { + return getText().equals(tags.peek()); + } + + public void popTag() { + tags.pop(); + } + + public boolean checkLA(int c) { + return getInputStream().LA(1) != c; + } + + public boolean charIsLetter() { + return Character.isLetter(getInputStream().LA(-1)); + } + + public void HandleNumericFail() { + getInputStream().seek(getInputStream().index() - 2); + setType(PostgreSqlLexer.Integral); + } + + public void HandleLessLessGreaterGreater() { + if (getText() == "<<") setType(PostgreSqlLexer.LESS_LESS); + if (getText() == ">>") setType(PostgreSqlLexer.GREATER_GREATER); + } + + public void UnterminatedBlockCommentDebugAssert() { + //Debug.Assert(InputStream.LA(1) == -1 /*EOF*/); + } + + public boolean CheckIfUtf32Letter() { + int codePoint = getInputStream().LA(-2) << 8 + getInputStream().LA(-1); + char[] c; + if (codePoint < 0x10000) { + c = new char[]{(char) codePoint}; + } else { + codePoint -= 0x10000; + c = new char[]{(char) (codePoint / 0x400 + 0xd800), (char) (codePoint % 0x400 + 0xdc00)}; + } + return Character.isLetter(c[0]); + } +} \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.java index 1ecb6597a..bccd40e75 100644 --- a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.java +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.java @@ -1,5 +1,7 @@ // Generated from PostgreSqlParser.g4 by ANTLR 4.13.1 package org.springframework.ide.vscode.parser.postgresql; + + import org.antlr.v4.runtime.atn.*; import org.antlr.v4.runtime.dfa.DFA; import org.antlr.v4.runtime.*; @@ -10,546 +12,830 @@ import java.util.Iterator; import java.util.ArrayList; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) -public class PostgreSqlParser extends Parser { +public class PostgreSqlParser extends PostgreSqlParserBase { static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int - WHITESPACE=1, BLOCK_COMMENT=2, LINE_COMMENT=3, A_=4, ABORT=5, ABS=6, ABSOLUTE=7, - ACCESS=8, ACTION=9, ADA=10, ADD=11, ADMIN=12, AFTER=13, AGGREGATE=14, - ALIAS=15, ALL=16, ALLOCATE=17, ALSO=18, ALTER=19, ALWAYS=20, ANALYSE=21, - ANALYZE=22, AND=23, ANY=24, ARE=25, ARRAY=26, AS=27, ASC=28, ASENSITIVE=29, - ASSERTION=30, ASSIGNMENT=31, ASYMMETRIC=32, AT=33, ATOMIC=34, ATTRIBUTE=35, - ATTRIBUTES=36, AUTHORIZATION=37, AVG=38, BACKWARD=39, BEFORE=40, BEGIN=41, - BERNOULLI=42, BETWEEN=43, BIGINT=44, BINARY=45, BIT=46, BIT_LENGTH=47, - BITVAR=48, BLOB=49, BOOLEAN=50, BOTH=51, BREADTH=52, BUFFERS=53, BY=54, - C_=55, CACHE=56, CALL=57, CALLED=58, CARDINALITY=59, CASCADE=60, CASCADED=61, - CASE=62, CAST=63, CATALOG=64, CATALOG_NAME=65, CEIL=66, CEILING=67, CHAIN=68, - CHAR=69, CHAR_LENGTH=70, CHARACTER=71, CHARACTER_LENGTH=72, CHARACTER_SET_CATALOG=73, - CHARACTER_SET_NAME=74, CHARACTER_SET_SCHEMA=75, CHARACTERISTICS=76, CHARACTERS=77, - CHECK=78, CHECKED=79, CHECKPOINT=80, CLASS=81, CLASS_ORIGIN=82, CLOB=83, - CLOSE=84, CLUSTER=85, COALESCE=86, COBOL=87, COLLATE=88, COLLATION=89, - COLLATION_CATALOG=90, COLLATION_NAME=91, COLLATION_SCHEMA=92, COLLECT=93, - COLUMN=94, COLUMN_NAME=95, COMMAND_FUNCTION=96, COMMAND_FUNCTION_CODE=97, - COMMENT=98, COMMIT=99, COMMITTED=100, COMPLETION=101, CONDITION=102, CONDITION_NUMBER=103, - CONFIGURATION=104, CONFLICT=105, CONNECT=106, CONNECTION=107, CONNECTION_NAME=108, - CONSTRAINT=109, CONSTRAINT_CATALOG=110, CONSTRAINT_NAME=111, CONSTRAINT_SCHEMA=112, - CONSTRAINTS=113, CONSTRUCTOR=114, CONTAINS=115, CONTINUE=116, CONVERSION=117, - CONVERT=118, COPY=119, CORR=120, CORRESPONDING=121, COSTS=122, COUNT=123, - COVAR_POP=124, COVAR_SAMP=125, CREATE=126, CREATEDB=127, CREATEUSER=128, - CROSS=129, CSV=130, CUBE=131, CUME_DIST=132, CURRENT=133, CURRENT_DATE=134, - CURRENT_DEFAULT_TRANSFORM_GROUP=135, CURRENT_PATH=136, CURRENT_ROLE=137, - CURRENT_TIME=138, CURRENT_TIMESTAMP=139, CURRENT_TRANSFORM_GROUP_FOR_TYPE=140, - CURRENT_USER=141, CURSOR=142, CURSOR_NAME=143, CYCLE=144, DATA=145, DATABASE=146, - DATE=147, DATETIME_INTERVAL_CODE=148, DATETIME_INTERVAL_PRECISION=149, - DAY=150, DEALLOCATE=151, DEC=152, DECIMAL=153, DECLARE=154, DEFAULT=155, - DEFAULTS=156, DEFERABLE=157, DEFERRABLE=158, DEFERRED=159, DEFINED=160, - DEFINER=161, DEGREE=162, DELETE=163, DELIMITER=164, DELIMITERS=165, DENSE_RANK=166, - DEPENDS=167, DEPTH=168, DEREF=169, DERIVED=170, DESC=171, DESCRIBE=172, - DESCRIPTOR=173, DESTROY=174, DESTRUCTOR=175, DETERMINISTIC=176, DIAGNOSTICS=177, - DICTIONARY=178, DISABLE=179, DISABLE_PAGE_SKIPPING=180, DISCARD=181, DISCONNECT=182, - DISPATCH=183, DISTINCT=184, DO=185, DOMAIN=186, DOUBLE=187, DROP=188, - DYNAMIC=189, DYNAMIC_FUNCTION=190, DYNAMIC_FUNCTION_CODE=191, EACH=192, - ELEMENT=193, ELSE=194, ENABLE=195, ENCODING=196, ENCRYPTED=197, END=198, - END_EXEC=199, EQUALS=200, ESCAPE=201, EVERY=202, EXCEPT=203, EXCEPTION=204, - EXCLUDE=205, EXCLUDING=206, EXCLUSIVE=207, EXEC=208, EXECUTE=209, EXISTING=210, - EXISTS=211, EXP=212, EXPLAIN=213, EXTENDED=214, EXTENSION=215, EXTERNAL=216, - EXTRACT=217, FALSE=218, FETCH=219, FIELDS=220, FILTER=221, FINAL=222, - FIRST=223, FLOAT=224, FLOOR=225, FOLLOWING=226, FOR=227, FORCE=228, FOREIGN=229, - FORMAT=230, FORTRAN=231, FORWARD=232, FOUND=233, FREE=234, FREEZE=235, - FROM=236, FULL=237, FUNCTION=238, FUSION=239, G_=240, GENERAL=241, GENERATED=242, - GET=243, GLOBAL=244, GO=245, GOTO=246, GRANT=247, GRANTED=248, GREATEST=249, - GROUP=250, GROUPING=251, HANDLER=252, HAVING=253, HIERARCHY=254, HOLD=255, - HOST=256, HOUR=257, IDENTITY=258, IGNORE=259, ILIKE=260, IMMEDIATE=261, - IMMUTABLE=262, IMPLEMENTATION=263, IMPLICIT=264, IN=265, INCLUDING=266, - INCREMENT=267, INDEX=268, INDICATOR=269, INFIX=270, INHERITS=271, INITIALIZE=272, - INITIALLY=273, INNER=274, INOUT=275, INPUT=276, INSENSITIVE=277, INSERT=278, - INSTANCE=279, INSTANTIABLE=280, INSTEAD=281, INT=282, INTEGER=283, INTERSECT=284, - INTERSECTION=285, INTERVAL=286, INTO=287, INVOKER=288, IS=289, ISOLATION=290, - ITERATE=291, JOIN=292, K_=293, KEY=294, KEY_MEMBER=295, KEY_TYPE=296, - LABEL=297, LANCOMPILER=298, LANGUAGE=299, LARGE=300, LAST=301, LATERAL=302, - LEADING=303, LEAST=304, LEFT=305, LENGTH=306, LESS=307, LEVEL=308, LIKE=309, - LIMIT=310, LISTEN=311, LN=312, LOAD=313, LOCAL=314, LOCALTIME=315, LOCALTIMESTAMP=316, - LOCATION=317, LOCATOR=318, LOCK=319, LOCKED=320, LOWER=321, M_=322, MAIN=323, - MAP=324, MAPPING=325, MATCH=326, MATCH_SIMPLE=327, MATCHED=328, MAX=329, - MAXVALUE=330, MEMBER=331, MERGE=332, MESSAGE_LENGTH=333, MESSAGE_OCTET_LENGTH=334, - MESSAGE_TEXT=335, METHOD=336, MIN=337, MINUTE=338, MINVALUE=339, MOD=340, - MODE=341, MODIFIES=342, MODIFY=343, MODULE=344, MONTH=345, MORE_=346, - MOVE=347, MULTISET=348, MUMPS=349, NAME=350, NAMES=351, NATIONAL=352, - NATURAL=353, NCHAR=354, NCLOB=355, NESTING=356, NEW=357, NEXT=358, NO=359, - NOCREATEDB=360, NOCREATEUSER=361, NONE=362, NORMALIZE=363, NORMALIZED=364, - NOT=365, NOTHING=366, NOTIFY=367, NOTNULL=368, NOWAIT=369, NULL=370, NULLABLE=371, - NULLIF=372, NULLS=373, NUMBER=374, NUMERIC=375, OBJECT=376, OCTET_LENGTH=377, - OCTETS=378, OF=379, OFF=380, OFFSET=381, OIDS=382, OLD=383, ON=384, ONLY=385, - OPEN=386, OPERATION=387, OPERATOR=388, OPTION=389, OPTIONS=390, OR=391, - ORDER=392, ORDERING=393, ORDINALITY=394, OTHERS=395, OUT=396, OUTER=397, - OUTPUT=398, OVER=399, OVERLAPS=400, OVERLAY=401, OVERRIDING=402, OWNER=403, - PAD=404, PARAMETER=405, PARAMETER_MODE=406, PARAMETER_NAME=407, PARAMETER_ORDINAL_POSITION=408, - PARAMETER_SPECIFIC_CATALOG=409, PARAMETER_SPECIFIC_NAME=410, PARAMETER_SPECIFIC_SCHEMA=411, - PARAMETERS=412, PARSER=413, PARTIAL=414, PARTITION=415, PASCAL=416, PASSWORD=417, - PATH=418, PERCENT_RANK=419, PERCENTILE_CONT=420, PERCENTILE_DISC=421, - PLACING=422, PLAIN=423, PLANS=424, PLI=425, POSITION=426, POSTFIX=427, - POWER=428, PRECEDING=429, PRECISION=430, PREFIX=431, PREORDER=432, PREPARE=433, - PREPARED=434, PRESERVE=435, PRIMARY=436, PRIOR=437, PRIVILEGES=438, PROCEDURAL=439, - PROCEDURE=440, PUBLIC=441, PUBLICATION=442, QUOTE=443, RANGE=444, RANK=445, - READ=446, READS=447, REAL=448, REASSIGN=449, RECHECK=450, RECURSIVE=451, - REF=452, REFERENCES=453, REFERENCING=454, REFRESH=455, REGR_AVGX=456, - REGR_AVGY=457, REGR_COUNT=458, REGR_INTERCEPT=459, REGR_R2=460, REGR_SLOPE=461, - REGR_SXX=462, REGR_SXY=463, REGR_SYY=464, REINDEX=465, RELATIVE=466, RELEASE=467, - RENAME=468, REPEATABLE=469, REPLACE=470, REPLICA=471, RESET=472, RESTART=473, - RESTRICT=474, RESULT=475, RETURN=476, RETURNED_CARDINALITY=477, RETURNED_LENGTH=478, - RETURNED_OCTET_LENGTH=479, RETURNED_SQLSTATE=480, RETURNING=481, RETURNS=482, - REVOKE=483, RIGHT=484, ROLE=485, ROLLBACK=486, ROLLUP=487, ROUTINE=488, - ROUTINE_CATALOG=489, ROUTINE_NAME=490, ROUTINE_SCHEMA=491, ROW=492, ROW_COUNT=493, - ROW_NUMBER=494, ROWS=495, RULE=496, SAVEPOINT=497, SCALE=498, SCHEMA=499, - SCHEMA_NAME=500, SCOPE=501, SCOPE_CATALOG=502, SCOPE_NAME=503, SCOPE_SCHEMA=504, - SCROLL=505, SEARCH=506, SECOND=507, SECTION=508, SECURITY=509, SELECT=510, - SELF=511, SENSITIVE=512, SEQUENCE=513, SEQUENCES=514, SERIALIZABLE=515, - SERVER_NAME=516, SESSION=517, SESSION_USER=518, SET=519, SETOF=520, SETS=521, - SHARE=522, SHOW=523, SIMILAR=524, SIMPLE=525, SIZE=526, SKIP_=527, SMALLINT=528, - SNAPSHOT=529, SOME=530, SOURCE=531, SPACE=532, SPECIFIC=533, SPECIFIC_NAME=534, - SPECIFICTYPE=535, SQL=536, SQLCODE=537, SQLERROR=538, SQLEXCEPTION=539, - SQLSTATE=540, SQLWARNING=541, SQRT=542, STABLE=543, START=544, STATE=545, - STATEMENT=546, STATIC=547, STATISTICS=548, STDDEV_POP=549, STDDEV_SAMP=550, - STDIN=551, STDOUT=552, STORAGE=553, STRICT=554, STRUCTURE=555, STYLE=556, - SUBCLASS_ORIGIN=557, SUBLIST=558, SUBMULTISET=559, SUBSCRIPTION=560, SUBSTRING=561, - SUM=562, SYMMETRIC=563, SYSID=564, SYSTEM=565, SYSTEM_USER=566, TABLE=567, - TABLE_NAME=568, TABLESAMPLE=569, TABLESPACE=570, TEMP=571, TEMPLATE=572, - TEMPORARY=573, TERMINATE=574, THAN=575, THEN=576, TIES=577, TIME=578, - TIMESTAMP=579, TIMEZONE_HOUR=580, TIMEZONE_MINUTE=581, TIMING=582, TO=583, - TOAST=584, TOP=585, TOP_LEVEL_COUNT=586, TRAILING=587, TRANSACTION=588, - TRANSACTION_ACTIVE=589, TRANSACTIONS_COMMITTED=590, TRANSACTIONS_ROLLED_BACK=591, - TRANSFORM=592, TRANSFORMS=593, TRANSLATE=594, TRANSLATION=595, TREAT=596, - TRIGGER=597, TRIGGER_CATALOG=598, TRIGGER_NAME=599, TRIGGER_SCHEMA=600, - TRIM=601, TRUE=602, TRUNCATE=603, TRUSTED=604, TYPE=605, UESCAPE=606, - UNBOUNDED=607, UNCOMMITTED=608, UNDER=609, UNENCRYPTED=610, UNION=611, - UNIQUE=612, UNKNOWN=613, UNLISTEN=614, UNLOGGED=615, UNNAMED=616, UNNEST=617, - UNTIL=618, UPDATE=619, UPPER=620, USAGE=621, USER=622, USER_DEFINED_TYPE_CATALOG=623, - USER_DEFINED_TYPE_CODE=624, USER_DEFINED_TYPE_NAME=625, USER_DEFINED_TYPE_SCHEMA=626, - USING=627, VACUUM=628, VALID=629, VALIDATE=630, VALIDATOR=631, VALUE=632, - VALUES=633, VAR_POP=634, VAR_SAMP=635, VARCHAR=636, VARIABLE=637, VARIADIC=638, - VARYING=639, VERBOSE=640, VIEW=641, VOLATILE=642, WHEN=643, WHENEVER=644, - WHERE=645, WIDTH_BUCKET=646, WINDOW=647, WITH=648, WITHIN=649, WITHOUT=650, - WORK=651, WRITE=652, YAML=653, YEAR=654, YES=655, ZONE=656, SUPERUSER=657, - NOSUPERUSER=658, CREATEROLE=659, NOCREATEROLE=660, INHERIT=661, NOINHERIT=662, - LOGIN=663, NOLOGIN=664, REPLICATION=665, NOREPLICATION=666, BYPASSRLS=667, - NOBYPASSRLS=668, SFUNC=669, STYPE=670, SSPACE=671, FINALFUNC=672, FINALFUNC_EXTRA=673, - COMBINEFUNC=674, SERIALFUNC=675, DESERIALFUNC=676, INITCOND=677, MSFUNC=678, - MINVFUNC=679, MSTYPE=680, MSSPACE=681, MFINALFUNC=682, MFINALFUNC_EXTRA=683, - MINITCOND=684, SORTOP=685, PARALLEL=686, HYPOTHETICAL=687, SAFE=688, RESTRICTED=689, - UNSAFE=690, BASETYPE=691, IF=692, LOCALE=693, LC_COLLATE=694, LC_CTYPE=695, - PROVIDER=696, VERSION=697, ALLOW_CONNECTIONS=698, IS_TEMPLATE=699, EVENT=700, - WRAPPER=701, SERVER=702, BTREE=703, HASH_=704, GIST=705, SPGIST=706, GIN=707, - BRIN=708, CONCURRENTLY=709, INLINE=710, MATERIALIZED=711, LEFTARG=712, - RIGHTARG=713, COMMUTATOR=714, NEGATOR=715, HASHES=716, MERGES=717, FAMILY=718, - POLICY=719, OWNED=720, ABSTIME=721, BIGSERIAL=722, BIT_VARYING=723, BOOL=724, - BOX=725, BYTEA=726, CHARACTER_VARYING=727, CIDR=728, CIRCLE=729, FLOAT4=730, - FLOAT8=731, INET=732, INT2=733, INT4=734, INT8=735, JSON=736, JSONB=737, - LINE=738, LSEG=739, MACADDR=740, MACADDR8=741, MONEY=742, PG_LSN=743, - POINT=744, POLYGON=745, RELTIME=746, SERIAL=747, SERIAL2=748, SERIAL4=749, - SERIAL8=750, SMALLSERIAL=751, STSTEM=752, TEXT=753, TIMESTAMPTZ=754, TIMETZ=755, - TSQUERY=756, TSVECTOR=757, TXID_SNAPSHOT=758, UUID=759, VARBIT=760, XML=761, - COMMA=762, COLON=763, COLON_COLON=764, DOLLAR=765, DOLLAR_DOLLAR=766, - STAR=767, OPEN_PAREN=768, CLOSE_PAREN=769, OPEN_BRACKET=770, CLOSE_BRACKET=771, - BIT_STRING=772, REGEX_STRING=773, NUMERIC_LITERAL=774, INTEGER_LITERAL=775, - HEX_INTEGER_LITERAL=776, DOT=777, SINGLEQ_STRING_LITERAL=778, DOUBLEQ_STRING_LITERAL=779, - IDENTIFIER=780, DOLLAR_DEC=781, IDENTIFIER_UNICODE=782, AMP=783, AMP_AMP=784, - AMP_LT=785, AT_AT=786, AT_GT=787, AT_SIGN=788, BANG=789, BANG_BANG=790, - BANG_EQUAL=791, CARET=792, EQUAL=793, EQUAL_GT=794, GT=795, GTE=796, GT_GT=797, - HASH=798, HASH_EQ=799, HASH_GT=800, HASH_GT_GT=801, HASH_HASH=802, HYPHEN_GT=803, - HYPHEN_GT_GT=804, HYPHEN_PIPE_HYPHEN=805, LT=806, LTE=807, LT_AT=808, - LT_CARET=809, LT_GT=810, LT_HYPHEN_GT=811, LT_LT=812, LT_LT_EQ=813, LT_QMARK_GT=814, - MINUS=815, PERCENT=816, PIPE=817, PIPE_PIPE=818, PIPE_PIPE_SLASH=819, - PIPE_SLASH=820, PLUS=821, QMARK=822, QMARK_AMP=823, QMARK_HASH=824, QMARK_HYPHEN=825, - QMARK_PIPE=826, SLASH=827, TIL=828, TIL_EQ=829, TIL_GTE_TIL=830, TIL_GT_TIL=831, - TIL_LTE_TIL=832, TIL_LT_TIL=833, TIL_STAR=834, TIL_TIL=835, SEMI=836, - SPEL=837; + SPEL=1, Dollar=2, OPEN_PAREN=3, CLOSE_PAREN=4, OPEN_BRACKET=5, CLOSE_BRACKET=6, + COMMA=7, SEMI=8, COLON=9, QUESTION=10, STAR=11, EQUAL=12, DOT=13, PLUS=14, + MINUS=15, SLASH=16, CARET=17, LT=18, GT=19, LESS_LESS=20, GREATER_GREATER=21, + COLON_EQUALS=22, LESS_EQUALS=23, EQUALS_GREATER=24, GREATER_EQUALS=25, + DOT_DOT=26, NOT_EQUALS=27, TYPECAST=28, PERCENT=29, PARAM=30, Operator=31, + ALL=32, ANALYSE=33, ANALYZE=34, AND=35, ANY=36, ARRAY=37, AS=38, ASC=39, + ASYMMETRIC=40, BOTH=41, CASE=42, CAST=43, CHECK=44, COLLATE=45, COLUMN=46, + CONSTRAINT=47, CREATE=48, CURRENT_CATALOG=49, CURRENT_DATE=50, CURRENT_ROLE=51, + CURRENT_TIME=52, CURRENT_TIMESTAMP=53, CURRENT_USER=54, DEFAULT=55, DEFERRABLE=56, + DESC=57, DISTINCT=58, DO=59, ELSE=60, EXCEPT=61, FALSE_P=62, FETCH=63, + FOR=64, FOREIGN=65, FROM=66, GRANT=67, GROUP_P=68, HAVING=69, IN_P=70, + INITIALLY=71, INTERSECT=72, INTO=73, LATERAL_P=74, LEADING=75, LIMIT=76, + LOCALTIME=77, LOCALTIMESTAMP=78, NOT=79, NULL_P=80, OFFSET=81, ON=82, + ONLY=83, OR=84, ORDER=85, PLACING=86, PRIMARY=87, REFERENCES=88, RETURNING=89, + SELECT=90, SESSION_USER=91, SOME=92, SYMMETRIC=93, TABLE=94, THEN=95, + TO=96, TRAILING=97, TRUE_P=98, UNION=99, UNIQUE=100, USER=101, USING=102, + VARIADIC=103, WHEN=104, WHERE=105, WINDOW=106, WITH=107, AUTHORIZATION=108, + BINARY=109, COLLATION=110, CONCURRENTLY=111, CROSS=112, CURRENT_SCHEMA=113, + FREEZE=114, FULL=115, ILIKE=116, INNER_P=117, IS=118, ISNULL=119, JOIN=120, + LEFT=121, LIKE=122, NATURAL=123, NOTNULL=124, OUTER_P=125, OVER=126, OVERLAPS=127, + RIGHT=128, SIMILAR=129, VERBOSE=130, ABORT_P=131, ABSOLUTE_P=132, ACCESS=133, + ACTION=134, ADD_P=135, ADMIN=136, AFTER=137, AGGREGATE=138, ALSO=139, + ALTER=140, ALWAYS=141, ASSERTION=142, ASSIGNMENT=143, AT=144, ATTRIBUTE=145, + BACKWARD=146, BEFORE=147, BEGIN_P=148, BY=149, CACHE=150, CALLED=151, + CASCADE=152, CASCADED=153, CATALOG=154, CHAIN=155, CHARACTERISTICS=156, + CHECKPOINT=157, CLASS=158, CLOSE=159, CLUSTER=160, COMMENT=161, COMMENTS=162, + COMMIT=163, COMMITTED=164, CONFIGURATION=165, CONNECTION=166, CONSTRAINTS=167, + CONTENT_P=168, CONTINUE_P=169, CONVERSION_P=170, COPY=171, COST=172, CSV=173, + CURSOR=174, CYCLE=175, DATA_P=176, DATABASE=177, DAY_P=178, DEALLOCATE=179, + DECLARE=180, DEFAULTS=181, DEFERRED=182, DEFINER=183, DELETE_P=184, DELIMITER=185, + DELIMITERS=186, DICTIONARY=187, DISABLE_P=188, DISCARD=189, DOCUMENT_P=190, + DOMAIN_P=191, DOUBLE_P=192, DROP=193, EACH=194, ENABLE_P=195, ENCODING=196, + ENCRYPTED=197, ENUM_P=198, ESCAPE=199, EVENT=200, EXCLUDE=201, EXCLUDING=202, + EXCLUSIVE=203, EXECUTE=204, EXPLAIN=205, EXTENSION=206, EXTERNAL=207, + FAMILY=208, FIRST_P=209, FOLLOWING=210, FORCE=211, FORWARD=212, FUNCTION=213, + FUNCTIONS=214, GLOBAL=215, GRANTED=216, HANDLER=217, HEADER_P=218, HOLD=219, + HOUR_P=220, IDENTITY_P=221, IF_P=222, IMMEDIATE=223, IMMUTABLE=224, IMPLICIT_P=225, + INCLUDING=226, INCREMENT=227, INDEX=228, INDEXES=229, INHERIT=230, INHERITS=231, + INLINE_P=232, INSENSITIVE=233, INSERT=234, INSTEAD=235, INVOKER=236, ISOLATION=237, + KEY=238, LABEL=239, LANGUAGE=240, LARGE_P=241, LAST_P=242, LEAKPROOF=243, + LEVEL=244, LISTEN=245, LOAD=246, LOCAL=247, LOCATION=248, LOCK_P=249, + MAPPING=250, MATCH=251, MATCHED=252, MATERIALIZED=253, MAXVALUE=254, MERGE=255, + MINUTE_P=256, MINVALUE=257, MODE=258, MONTH_P=259, MOVE=260, NAME_P=261, + NAMES=262, NEXT=263, NO=264, NOTHING=265, NOTIFY=266, NOWAIT=267, NULLS_P=268, + OBJECT_P=269, OF=270, OFF=271, OIDS=272, OPERATOR=273, OPTION=274, OPTIONS=275, + OWNED=276, OWNER=277, PARSER=278, PARTIAL=279, PARTITION=280, PASSING=281, + PASSWORD=282, PLANS=283, PRECEDING=284, PREPARE=285, PREPARED=286, PRESERVE=287, + PRIOR=288, PRIVILEGES=289, PROCEDURAL=290, PROCEDURE=291, PROGRAM=292, + QUOTE=293, RANGE=294, READ=295, REASSIGN=296, RECHECK=297, RECURSIVE=298, + REF=299, REFRESH=300, REINDEX=301, RELATIVE_P=302, RELEASE=303, RENAME=304, + REPEATABLE=305, REPLACE=306, REPLICA=307, RESET=308, RESTART=309, RESTRICT=310, + RETURNS=311, REVOKE=312, ROLE=313, ROLLBACK=314, ROWS=315, RULE=316, SAVEPOINT=317, + SCHEMA=318, SCROLL=319, SEARCH=320, SECOND_P=321, SECURITY=322, SEQUENCE=323, + SEQUENCES=324, SERIALIZABLE=325, SERVER=326, SESSION=327, SET=328, SHARE=329, + SHOW=330, SIMPLE=331, SNAPSHOT=332, STABLE=333, STANDALONE_P=334, START=335, + STATEMENT=336, STATISTICS=337, STDIN=338, STDOUT=339, STORAGE=340, STRICT_P=341, + STRIP_P=342, SYSID=343, SYSTEM_P=344, TABLES=345, TABLESPACE=346, TEMP=347, + TEMPLATE=348, TEMPORARY=349, TEXT_P=350, TRANSACTION=351, TRIGGER=352, + TRUNCATE=353, TRUSTED=354, TYPE_P=355, TYPES_P=356, UNBOUNDED=357, UNCOMMITTED=358, + UNENCRYPTED=359, UNKNOWN=360, UNLISTEN=361, UNLOGGED=362, UNTIL=363, UPDATE=364, + VACUUM=365, VALID=366, VALIDATE=367, VALIDATOR=368, VARYING=369, VERSION_P=370, + VIEW=371, VOLATILE=372, WHITESPACE_P=373, WITHOUT=374, WORK=375, WRAPPER=376, + WRITE=377, XML_P=378, YEAR_P=379, YES_P=380, ZONE=381, BETWEEN=382, BIGINT=383, + BIT=384, BOOLEAN_P=385, CHAR_P=386, CHARACTER=387, COALESCE=388, DEC=389, + DECIMAL_P=390, EXISTS=391, EXTRACT=392, FLOAT_P=393, GREATEST=394, INOUT=395, + INT_P=396, INTEGER=397, INTERVAL=398, LEAST=399, NATIONAL=400, NCHAR=401, + NONE=402, NULLIF=403, NUMERIC=404, OVERLAY=405, POSITION=406, PRECISION=407, + REAL=408, ROW=409, SETOF=410, SMALLINT=411, SUBSTRING=412, TIME=413, TIMESTAMP=414, + TREAT=415, TRIM=416, VALUES=417, VARCHAR=418, XMLATTRIBUTES=419, XMLCOMMENT=420, + XMLAGG=421, XML_IS_WELL_FORMED=422, XML_IS_WELL_FORMED_DOCUMENT=423, XML_IS_WELL_FORMED_CONTENT=424, + XPATH=425, XPATH_EXISTS=426, XMLCONCAT=427, XMLELEMENT=428, XMLEXISTS=429, + XMLFOREST=430, XMLPARSE=431, XMLPI=432, XMLROOT=433, XMLSERIALIZE=434, + CALL=435, CURRENT_P=436, ATTACH=437, DETACH=438, EXPRESSION=439, GENERATED=440, + LOGGED=441, STORED=442, INCLUDE=443, ROUTINE=444, TRANSFORM=445, IMPORT_P=446, + POLICY=447, METHOD=448, REFERENCING=449, NEW=450, OLD=451, VALUE_P=452, + SUBSCRIPTION=453, PUBLICATION=454, OUT_P=455, END_P=456, ROUTINES=457, + SCHEMAS=458, PROCEDURES=459, INPUT_P=460, SUPPORT=461, PARALLEL=462, SQL_P=463, + DEPENDS=464, OVERRIDING=465, CONFLICT=466, SKIP_P=467, LOCKED=468, TIES=469, + ROLLUP=470, CUBE=471, GROUPING=472, SETS=473, TABLESAMPLE=474, ORDINALITY=475, + XMLTABLE=476, COLUMNS=477, XMLNAMESPACES=478, ROWTYPE=479, NORMALIZED=480, + WITHIN=481, FILTER=482, GROUPS=483, OTHERS=484, NFC=485, NFD=486, NFKC=487, + NFKD=488, UESCAPE=489, VIEWS=490, NORMALIZE=491, DUMP=492, PRINT_STRICT_PARAMS=493, + VARIABLE_CONFLICT=494, ERROR=495, USE_VARIABLE=496, USE_COLUMN=497, ALIAS=498, + CONSTANT=499, PERFORM=500, GET=501, DIAGNOSTICS=502, STACKED=503, ELSIF=504, + WHILE=505, REVERSE=506, FOREACH=507, SLICE=508, EXIT=509, RETURN=510, + QUERY=511, RAISE=512, SQLSTATE=513, DEBUG=514, LOG=515, INFO=516, NOTICE=517, + WARNING=518, EXCEPTION=519, ASSERT=520, LOOP=521, OPEN=522, TOP=523, ABS=524, + CBRT=525, CEIL=526, CEILING=527, DEGREES=528, DIV=529, EXP=530, FACTORIAL=531, + FLOOR=532, GCD=533, LCM=534, LN=535, LOG10=536, MIN_SCALE=537, MOD=538, + PI=539, POWER=540, RADIANS=541, ROUND=542, SCALE=543, SIGN=544, SQRT=545, + TRIM_SCALE=546, TRUNC=547, WIDTH_BUCKET=548, RANDOM=549, SETSEED=550, + ACOS=551, ACOSD=552, ASIN=553, ASIND=554, ATAN=555, ATAND=556, ATAN2=557, + ATAN2D=558, COS=559, COSD=560, COT=561, COTD=562, SIN=563, SIND=564, TAN=565, + TAND=566, SINH=567, COSH=568, TANH=569, ASINH=570, ACOSH=571, ATANH=572, + BIT_LENGTH=573, CHAR_LENGTH=574, CHARACTER_LENGTH=575, LOWER=576, OCTET_LENGTH=577, + UPPER=578, ASCII=579, BTRIM=580, CHR=581, CONCAT=582, CONCAT_WS=583, FORMAT=584, + INITCAP=585, LENGTH=586, LPAD=587, LTRIM=588, MD5=589, PARSE_IDENT=590, + PG_CLIENT_ENCODING=591, QUOTE_IDENT=592, QUOTE_LITERAL=593, QUOTE_NULLABLE=594, + REGEXP_COUNT=595, REGEXP_INSTR=596, REGEXP_LIKE=597, REGEXP_MATCH=598, + REGEXP_MATCHES=599, REGEXP_REPLACE=600, REGEXP_SPLIT_TO_ARRAY=601, REGEXP_SPLIT_TO_TABLE=602, + REGEXP_SUBSTR=603, REPEAT=604, RPAD=605, RTRIM=606, SPLIT_PART=607, STARTS_WITH=608, + STRING_TO_ARRAY=609, STRING_TO_TABLE=610, STRPOS=611, SUBSTR=612, TO_ASCII=613, + TO_HEX=614, TRANSLATE=615, UNISTR=616, AGE=617, CLOCK_TIMESTAMP=618, DATE_BIN=619, + DATE_PART=620, DATE_TRUNC=621, ISFINITE=622, JUSTIFY_DAYS=623, JUSTIFY_HOURS=624, + JUSTIFY_INTERVAL=625, MAKE_DATE=626, MAKE_INTERVAL=627, MAKE_TIME=628, + MAKE_TIMESTAMP=629, MAKE_TIMESTAMPTZ=630, NOW=631, STATEMENT_TIMESTAMP=632, + TIMEOFDAY=633, TRANSACTION_TIMESTAMP=634, TO_TIMESTAMP=635, TO_CHAR=636, + TO_DATE=637, TO_NUMBER=638, Identifier=639, QuotedIdentifier=640, UnterminatedQuotedIdentifier=641, + InvalidQuotedIdentifier=642, InvalidUnterminatedQuotedIdentifier=643, + UnicodeQuotedIdentifier=644, UnterminatedUnicodeQuotedIdentifier=645, + InvalidUnicodeQuotedIdentifier=646, InvalidUnterminatedUnicodeQuotedIdentifier=647, + StringConstant=648, UnterminatedStringConstant=649, UnicodeEscapeStringConstant=650, + UnterminatedUnicodeEscapeStringConstant=651, BeginDollarStringConstant=652, + BinaryStringConstant=653, UnterminatedBinaryStringConstant=654, InvalidBinaryStringConstant=655, + InvalidUnterminatedBinaryStringConstant=656, HexadecimalStringConstant=657, + UnterminatedHexadecimalStringConstant=658, InvalidHexadecimalStringConstant=659, + InvalidUnterminatedHexadecimalStringConstant=660, Integral=661, NumericFail=662, + Numeric=663, PLSQLIDENTIFIER=664, Whitespace=665, Newline=666, LineComment=667, + BlockComment=668, UnterminatedBlockComment=669, MetaCommand=670, EndMetaCommand=671, + ErrorCharacter=672, EscapeStringConstant=673, UnterminatedEscapeStringConstant=674, + InvalidEscapeStringConstant=675, InvalidUnterminatedEscapeStringConstant=676, + DollarText=677, EndDollarStringConstant=678, AfterEscapeStringConstantWithNewlineMode_Continued=679; public static final int - RULE_root = 0, RULE_stmt = 1, RULE_abort_stmt = 2, RULE_alter_stmt = 3, - RULE_alter_aggregate_stmt = 4, RULE_alter_collation_stmt = 5, RULE_alter_conversion_stmt = 6, - RULE_alter_database_stmt = 7, RULE_alter_default_privileges_stmt = 8, - RULE_alter_domain_stmt = 9, RULE_alter_event_trigger_stmt = 10, RULE_alter_extension_stmt = 11, - RULE_alter_foreign_data_wrapper_stmt = 12, RULE_alter_foreign_table_action = 13, - RULE_alter_foreign_table_action_list = 14, RULE_alter_foreign_table_stmt = 15, - RULE_alter_function_stmt = 16, RULE_alter_group_stmt = 17, RULE_alter_index_stmt = 18, - RULE_alter_language_stmt = 19, RULE_alter_large_object_stmt = 20, RULE_alter_materialize_view_stmt = 21, - RULE_alter_operator_stmt = 22, RULE_alter_operator_class_stmt = 23, RULE_alter_operator_family_stmt = 24, - RULE_alter_policy_stmt = 25, RULE_alter_publication_stmt = 26, RULE_alter_role_options = 27, - RULE_alter_role_stmt = 28, RULE_alter_rule_stmt = 29, RULE_alter_schema_stmt = 30, - RULE_alter_sequence_stmt = 31, RULE_alter_server_options_list = 32, RULE_alter_server_stmt = 33, - RULE_alter_statistics_stmt = 34, RULE_alter_subscription_stmt = 35, RULE_alter_system_stmt = 36, - RULE_alter_table_stmt = 37, RULE_alter_tablespace_stmt = 38, RULE_alter_text_search_config_stmt = 39, - RULE_alter_text_search_dict_stmt = 40, RULE_alter_text_search_parser_stmt = 41, - RULE_alter_text_search_template_stmt = 42, RULE_alter_trigger_stmt = 43, - RULE_alter_type_stmt = 44, RULE_alter_user_stmt = 45, RULE_alter_user_mapping_stmt = 46, - RULE_alter_view_stmt = 47, RULE_analyze_stmt = 48, RULE_close_stmt = 49, - RULE_cluster_stmt = 50, RULE_comment_stmt = 51, RULE_commit_stmt = 52, - RULE_commit_prepared_stmt = 53, RULE_copy_stmt = 54, RULE_create_stmt = 55, - RULE_create_access_method_stmt = 56, RULE_create_aggregate_stmt = 57, - RULE_create_cast_stmt = 58, RULE_create_collation_opt = 59, RULE_create_collation_opt_list = 60, - RULE_create_collation_stmt = 61, RULE_create_conversion_stmt = 62, RULE_create_database_stmt = 63, - RULE_domain_constraint = 64, RULE_create_domain_stmt = 65, RULE_create_event_trigger_cond = 66, - RULE_create_event_trigger_stmt = 67, RULE_create_foreign_data_options = 68, - RULE_create_foreign_data_stmt = 69, RULE_create_foreign_table_stmt = 70, - RULE_create_function_stmt = 71, RULE_create_group_stmt = 72, RULE_create_index_stmt = 73, - RULE_create_language_stmt = 74, RULE_create_materialized_view_stmt = 75, - RULE_create_operator_stmt = 76, RULE_create_operator_class_opt = 77, RULE_create_operator_class_stmt = 78, - RULE_create_operator_family_stmt = 79, RULE_create_policy_stmt = 80, RULE_create_role_stmt = 81, - RULE_create_rule_event = 82, RULE_create_rule_stmt = 83, RULE_create_schema_stmt = 84, - RULE_create_sequence_stmt = 85, RULE_create_server_stmt = 86, RULE_create_statistics_stmt = 87, - RULE_create_subscription_stmt = 88, RULE_create_table_stmt = 89, RULE_create_table_as_stmt = 90, - RULE_create_tablespace_stmt = 91, RULE_create_text_search_config_stmt = 92, - RULE_create_text_search_dict_stmt = 93, RULE_create_text_search_parser_stmt = 94, - RULE_create_text_search_template_stmt = 95, RULE_create_transform_stmt = 96, - RULE_create_trigger_stmt = 97, RULE_create_type_stmt = 98, RULE_create_user_stmt = 99, - RULE_create_user_mapping_stmt = 100, RULE_create_view_stmt = 101, RULE_deallocate_stmt = 102, - RULE_declare_stmt = 103, RULE_delete_stmt = 104, RULE_discard_stmt = 105, - RULE_drop_stmt = 106, RULE_drop_access_method_stmt = 107, RULE_drop_aggregate_stmt = 108, - RULE_drop_cast_stmt = 109, RULE_drop_collation_stmt = 110, RULE_drop_conversion_stmt = 111, - RULE_drop_database_stmt = 112, RULE_drop_domain_stmt = 113, RULE_drop_event_trigger_stmt = 114, - RULE_drop_extension_stmt = 115, RULE_drop_foreign_data_wrapper_stmt = 116, - RULE_drop_foreign_table_stmt = 117, RULE_drop_function_stmt = 118, RULE_drop_group_stmt = 119, - RULE_drop_index_stmt = 120, RULE_drop_language_stmt = 121, RULE_drop_materialized_view_stmt = 122, - RULE_drop_operator_stmt = 123, RULE_drop_operator_class_stmt = 124, RULE_drop_operator_family_stmt = 125, - RULE_drop_owned_stmt = 126, RULE_drop_policy_stmt = 127, RULE_drop_publication_stmt = 128, - RULE_drop_role_stmt = 129, RULE_drop_rule_stmt = 130, RULE_drop_schema_stmt = 131, - RULE_drop_sequence_stmt = 132, RULE_drop_server_stmt = 133, RULE_drop_statistics_stmt = 134, - RULE_drop_subscription_stmt = 135, RULE_drop_table_stmt = 136, RULE_drop_tablespace_stmt = 137, - RULE_drop_text_search_config_stmt = 138, RULE_drop_text_search_dict_stmt = 139, - RULE_drop_text_search_parser_stmt = 140, RULE_drop_text_search_template_stmt = 141, - RULE_drop_transform_stmt = 142, RULE_drop_trigger_stmt = 143, RULE_drop_type_stmt = 144, - RULE_drop_user_stmt = 145, RULE_drop_user_mapping_stmt = 146, RULE_drop_view_stmt = 147, - RULE_execute_stmt = 148, RULE_explain_stmt = 149, RULE_fetch_stmt = 150, - RULE_grant_stmt = 151, RULE_import_foreign_schema_stmt = 152, RULE_insert_stmt = 153, - RULE_listen_stmt = 154, RULE_load_stmt = 155, RULE_lock_stmt = 156, RULE_move_stmt = 157, - RULE_notify_stmt = 158, RULE_prepare_stmt = 159, RULE_prepare_transaction_stmt = 160, - RULE_reassign_owned_stmt = 161, RULE_refresh_materialized_view_stmt = 162, - RULE_reindex_stmt = 163, RULE_release_savepoint_stmt = 164, RULE_reset_stmt = 165, - RULE_revoke_stmt = 166, RULE_rollback_stmt = 167, RULE_rollback_prepared_stmt = 168, - RULE_rollback_to_savepoint_stmt = 169, RULE_savepoint_stmt = 170, RULE_security_label_stmt = 171, - RULE_select_stmt = 172, RULE_select_into_stmt = 173, RULE_with_clause = 174, - RULE_with_expr = 175, RULE_set_stmt = 176, RULE_set_constraints_stmt = 177, - RULE_set_role_stmt = 178, RULE_set_session_authorization_stmt = 179, RULE_transaction_mode = 180, - RULE_transaction_mode_list = 181, RULE_set_transaction_stmt = 182, RULE_show_stmt = 183, - RULE_truncate_stmt = 184, RULE_unlisten_stmt = 185, RULE_update_stmt = 186, - RULE_vacuum_opt = 187, RULE_vacuum_opt_list = 188, RULE_vacuum_stmt = 189, - RULE_values_stmt = 190, RULE_selector_clause = 191, RULE_from_clause = 192, - RULE_where_clause = 193, RULE_group_by_clause = 194, RULE_grouping_elem = 195, - RULE_grouping_elem_list = 196, RULE_having_clause = 197, RULE_column_list = 198, - RULE_explain_parameter = 199, RULE_frame = 200, RULE_frame_start = 201, - RULE_frame_end = 202, RULE_frame_clause = 203, RULE_window_definition_list = 204, - RULE_window_definition = 205, RULE_window_clause = 206, RULE_window_specification = 207, - RULE_partition_clause = 208, RULE_over_clause = 209, RULE_combine_clause = 210, - RULE_order_by_clause = 211, RULE_order_by_item = 212, RULE_limit_clause = 213, - RULE_offset_clause = 214, RULE_fetch_clause = 215, RULE_for_clause = 216, - RULE_updater_clause = 217, RULE_updater_expr = 218, RULE_returning_clause = 219, - RULE_expr = 220, RULE_parameter = 221, RULE_parameterOrIntegerLiteral = 222, - RULE_parameterOrNumericLiteral = 223, RULE_bool_expr = 224, RULE_case_expr = 225, - RULE_expr_list = 226, RULE_expr_list_list = 227, RULE_func_sig_arg = 228, - RULE_func_sig_arg_list = 229, RULE_func_sig = 230, RULE_func_sig_list = 231, - RULE_type_name = 232, RULE_timezone = 233, RULE_oper = 234, RULE_aggregate = 235, - RULE_name_ = 236, RULE_name_list = 237, RULE_identifier_list = 238, RULE_option_expr = 239, - RULE_option_list = 240, RULE_table_name_ = 241, RULE_data_type = 242, - RULE_data_type_list = 243, RULE_index_method = 244, RULE_func_name = 245, - RULE_func_call = 246, RULE_array_cons_expr = 247, RULE_from_item = 248, - RULE_with_column_alias = 249, RULE_join_type = 250, RULE_join_clause = 251, - RULE_predicate = 252, RULE_aggregate_signature = 253, RULE_column_constraint = 254, - RULE_column_constraints = 255, RULE_index_parameters = 256, RULE_exclude_element = 257, - RULE_table_constraint = 258, RULE_role_name = 259, RULE_role_name_list = 260, - RULE_param_value = 261, RULE_reserved_keyword = 262, RULE_non_reserved_keyword = 263, - RULE_identifier = 264, RULE_todo_fill_in = 265, RULE_todo_implement = 266, - RULE_correlation_name = 267, RULE_column_name = 268, RULE_alias = 269, - RULE_column_alias = 270, RULE_column_definition = 271, RULE_window_name = 272; + RULE_root = 0, RULE_plsqlroot = 1, RULE_stmtblock = 2, RULE_stmtmulti = 3, + RULE_stmt = 4, RULE_plsqlconsolecommand = 5, RULE_callstmt = 6, RULE_createrolestmt = 7, + RULE_opt_with = 8, RULE_optrolelist = 9, RULE_alteroptrolelist = 10, RULE_alteroptroleelem = 11, + RULE_createoptroleelem = 12, RULE_createuserstmt = 13, RULE_alterrolestmt = 14, + RULE_opt_in_database = 15, RULE_alterrolesetstmt = 16, RULE_droprolestmt = 17, + RULE_creategroupstmt = 18, RULE_altergroupstmt = 19, RULE_add_drop = 20, + RULE_createschemastmt = 21, RULE_optschemaname = 22, RULE_optschemaeltlist = 23, + RULE_schema_stmt = 24, RULE_variablesetstmt = 25, RULE_set_rest = 26, + RULE_generic_set = 27, RULE_set_rest_more = 28, RULE_var_name = 29, RULE_var_list = 30, + RULE_var_value = 31, RULE_iso_level = 32, RULE_opt_boolean_or_string = 33, + RULE_zone_value = 34, RULE_opt_encoding = 35, RULE_nonreservedword_or_sconst = 36, + RULE_variableresetstmt = 37, RULE_reset_rest = 38, RULE_generic_reset = 39, + RULE_setresetclause = 40, RULE_functionsetresetclause = 41, RULE_variableshowstmt = 42, + RULE_constraintssetstmt = 43, RULE_constraints_set_list = 44, RULE_constraints_set_mode = 45, + RULE_checkpointstmt = 46, RULE_discardstmt = 47, RULE_altertablestmt = 48, + RULE_alter_table_cmds = 49, RULE_partition_cmd = 50, RULE_index_partition_cmd = 51, + RULE_alter_table_cmd = 52, RULE_alter_column_default = 53, RULE_opt_drop_behavior = 54, + RULE_opt_collate_clause = 55, RULE_alter_using = 56, RULE_replica_identity = 57, + RULE_reloptions = 58, RULE_opt_reloptions = 59, RULE_reloption_list = 60, + RULE_reloption_elem = 61, RULE_alter_identity_column_option_list = 62, + RULE_alter_identity_column_option = 63, RULE_partitionboundspec = 64, + RULE_hash_partbound_elem = 65, RULE_hash_partbound = 66, RULE_altercompositetypestmt = 67, + RULE_alter_type_cmds = 68, RULE_alter_type_cmd = 69, RULE_closeportalstmt = 70, + RULE_copystmt = 71, RULE_copy_from = 72, RULE_opt_program = 73, RULE_copy_file_name = 74, + RULE_copy_options = 75, RULE_copy_opt_list = 76, RULE_copy_opt_item = 77, + RULE_opt_binary = 78, RULE_copy_delimiter = 79, RULE_opt_using = 80, RULE_copy_generic_opt_list = 81, + RULE_copy_generic_opt_elem = 82, RULE_copy_generic_opt_arg = 83, RULE_copy_generic_opt_arg_list = 84, + RULE_copy_generic_opt_arg_list_item = 85, RULE_createstmt = 86, RULE_opttemp = 87, + RULE_opttableelementlist = 88, RULE_opttypedtableelementlist = 89, RULE_tableelementlist = 90, + RULE_typedtableelementlist = 91, RULE_tableelement = 92, RULE_typedtableelement = 93, + RULE_columnDef = 94, RULE_columnOptions = 95, RULE_colquallist = 96, RULE_colconstraint = 97, + RULE_colconstraintelem = 98, RULE_generated_when = 99, RULE_constraintattr = 100, + RULE_tablelikeclause = 101, RULE_tablelikeoptionlist = 102, RULE_tablelikeoption = 103, + RULE_tableconstraint = 104, RULE_constraintelem = 105, RULE_opt_no_inherit = 106, + RULE_opt_column_list = 107, RULE_columnlist = 108, RULE_columnElem = 109, + RULE_opt_c_include = 110, RULE_key_match = 111, RULE_exclusionconstraintlist = 112, + RULE_exclusionconstraintelem = 113, RULE_exclusionwhereclause = 114, RULE_key_actions = 115, + RULE_key_update = 116, RULE_key_delete = 117, RULE_key_action = 118, RULE_optinherit = 119, + RULE_optpartitionspec = 120, RULE_partitionspec = 121, RULE_part_params = 122, + RULE_part_elem = 123, RULE_table_access_method_clause = 124, RULE_optwith = 125, + RULE_oncommitoption = 126, RULE_opttablespace = 127, RULE_optconstablespace = 128, + RULE_existingindex = 129, RULE_createstatsstmt = 130, RULE_alterstatsstmt = 131, + RULE_createasstmt = 132, RULE_create_as_target = 133, RULE_opt_with_data = 134, + RULE_creatematviewstmt = 135, RULE_create_mv_target = 136, RULE_optnolog = 137, + RULE_refreshmatviewstmt = 138, RULE_createseqstmt = 139, RULE_alterseqstmt = 140, + RULE_optseqoptlist = 141, RULE_optparenthesizedseqoptlist = 142, RULE_seqoptlist = 143, + RULE_seqoptelem = 144, RULE_opt_by = 145, RULE_numericonly = 146, RULE_numericonly_list = 147, + RULE_createplangstmt = 148, RULE_opt_trusted = 149, RULE_handler_name = 150, + RULE_opt_inline_handler = 151, RULE_validator_clause = 152, RULE_opt_validator = 153, + RULE_opt_procedural = 154, RULE_createtablespacestmt = 155, RULE_opttablespaceowner = 156, + RULE_droptablespacestmt = 157, RULE_createextensionstmt = 158, RULE_create_extension_opt_list = 159, + RULE_create_extension_opt_item = 160, RULE_alterextensionstmt = 161, RULE_alter_extension_opt_list = 162, + RULE_alter_extension_opt_item = 163, RULE_alterextensioncontentsstmt = 164, + RULE_createfdwstmt = 165, RULE_fdw_option = 166, RULE_fdw_options = 167, + RULE_opt_fdw_options = 168, RULE_alterfdwstmt = 169, RULE_create_generic_options = 170, + RULE_generic_option_list = 171, RULE_alter_generic_options = 172, RULE_alter_generic_option_list = 173, + RULE_alter_generic_option_elem = 174, RULE_generic_option_elem = 175, + RULE_generic_option_name = 176, RULE_generic_option_arg = 177, RULE_createforeignserverstmt = 178, + RULE_opt_type = 179, RULE_foreign_server_version = 180, RULE_opt_foreign_server_version = 181, + RULE_alterforeignserverstmt = 182, RULE_createforeigntablestmt = 183, + RULE_importforeignschemastmt = 184, RULE_import_qualification_type = 185, + RULE_import_qualification = 186, RULE_createusermappingstmt = 187, RULE_auth_ident = 188, + RULE_dropusermappingstmt = 189, RULE_alterusermappingstmt = 190, RULE_createpolicystmt = 191, + RULE_alterpolicystmt = 192, RULE_rowsecurityoptionalexpr = 193, RULE_rowsecurityoptionalwithcheck = 194, + RULE_rowsecuritydefaulttorole = 195, RULE_rowsecurityoptionaltorole = 196, + RULE_rowsecuritydefaultpermissive = 197, RULE_rowsecuritydefaultforcmd = 198, + RULE_row_security_cmd = 199, RULE_createamstmt = 200, RULE_am_type = 201, + RULE_createtrigstmt = 202, RULE_triggeractiontime = 203, RULE_triggerevents = 204, + RULE_triggeroneevent = 205, RULE_triggerreferencing = 206, RULE_triggertransitions = 207, + RULE_triggertransition = 208, RULE_transitionoldornew = 209, RULE_transitionrowortable = 210, + RULE_transitionrelname = 211, RULE_triggerforspec = 212, RULE_triggerforopteach = 213, + RULE_triggerfortype = 214, RULE_triggerwhen = 215, RULE_function_or_procedure = 216, + RULE_triggerfuncargs = 217, RULE_triggerfuncarg = 218, RULE_optconstrfromtable = 219, + RULE_constraintattributespec = 220, RULE_constraintattributeElem = 221, + RULE_createeventtrigstmt = 222, RULE_event_trigger_when_list = 223, RULE_event_trigger_when_item = 224, + RULE_event_trigger_value_list = 225, RULE_altereventtrigstmt = 226, RULE_enable_trigger = 227, + RULE_createassertionstmt = 228, RULE_definestmt = 229, RULE_definition = 230, + RULE_def_list = 231, RULE_def_elem = 232, RULE_def_arg = 233, RULE_old_aggr_definition = 234, + RULE_old_aggr_list = 235, RULE_old_aggr_elem = 236, RULE_opt_enum_val_list = 237, + RULE_enum_val_list = 238, RULE_alterenumstmt = 239, RULE_opt_if_not_exists = 240, + RULE_createopclassstmt = 241, RULE_opclass_item_list = 242, RULE_opclass_item = 243, + RULE_opt_default = 244, RULE_opt_opfamily = 245, RULE_opclass_purpose = 246, + RULE_opt_recheck = 247, RULE_createopfamilystmt = 248, RULE_alteropfamilystmt = 249, + RULE_opclass_drop_list = 250, RULE_opclass_drop = 251, RULE_dropopclassstmt = 252, + RULE_dropopfamilystmt = 253, RULE_dropownedstmt = 254, RULE_reassignownedstmt = 255, + RULE_dropstmt = 256, RULE_object_type_any_name = 257, RULE_object_type_name = 258, + RULE_drop_type_name = 259, RULE_object_type_name_on_any_name = 260, RULE_any_name_list = 261, + RULE_any_name = 262, RULE_attrs = 263, RULE_type_name_list = 264, RULE_truncatestmt = 265, + RULE_opt_restart_seqs = 266, RULE_commentstmt = 267, RULE_comment_text = 268, + RULE_seclabelstmt = 269, RULE_opt_provider = 270, RULE_security_label = 271, + RULE_fetchstmt = 272, RULE_fetch_args = 273, RULE_from_in = 274, RULE_opt_from_in = 275, + RULE_grantstmt = 276, RULE_revokestmt = 277, RULE_privileges = 278, RULE_privilege_list = 279, + RULE_privilege = 280, RULE_privilege_target = 281, RULE_grantee_list = 282, + RULE_grantee = 283, RULE_opt_grant_grant_option = 284, RULE_grantrolestmt = 285, + RULE_revokerolestmt = 286, RULE_opt_grant_admin_option = 287, RULE_opt_granted_by = 288, + RULE_alterdefaultprivilegesstmt = 289, RULE_defacloptionlist = 290, RULE_defacloption = 291, + RULE_defaclaction = 292, RULE_defacl_privilege_target = 293, RULE_indexstmt = 294, + RULE_opt_unique = 295, RULE_opt_concurrently = 296, RULE_opt_index_name = 297, + RULE_access_method_clause = 298, RULE_index_params = 299, RULE_index_elem_options = 300, + RULE_index_elem = 301, RULE_opt_include = 302, RULE_index_including_params = 303, + RULE_opt_collate = 304, RULE_opt_class = 305, RULE_opt_asc_desc = 306, + RULE_opt_nulls_order = 307, RULE_createfunctionstmt = 308, RULE_opt_or_replace = 309, + RULE_func_args = 310, RULE_func_args_list = 311, RULE_function_with_argtypes_list = 312, + RULE_function_with_argtypes = 313, RULE_func_args_with_defaults = 314, + RULE_func_args_with_defaults_list = 315, RULE_func_arg = 316, RULE_arg_class = 317, + RULE_param_name = 318, RULE_func_return = 319, RULE_func_type = 320, RULE_func_arg_with_default = 321, + RULE_aggr_arg = 322, RULE_aggr_args = 323, RULE_aggr_args_list = 324, + RULE_aggregate_with_argtypes = 325, RULE_aggregate_with_argtypes_list = 326, + RULE_createfunc_opt_list = 327, RULE_common_func_opt_item = 328, RULE_createfunc_opt_item = 329, + RULE_func_as = 330, RULE_transform_type_list = 331, RULE_opt_definition = 332, + RULE_table_func_column = 333, RULE_table_func_column_list = 334, RULE_alterfunctionstmt = 335, + RULE_alterfunc_opt_list = 336, RULE_opt_restrict = 337, RULE_removefuncstmt = 338, + RULE_removeaggrstmt = 339, RULE_removeoperstmt = 340, RULE_oper_argtypes = 341, + RULE_any_operator = 342, RULE_operator_with_argtypes_list = 343, RULE_operator_with_argtypes = 344, + RULE_dostmt = 345, RULE_dostmt_opt_list = 346, RULE_dostmt_opt_item = 347, + RULE_createcaststmt = 348, RULE_cast_context = 349, RULE_dropcaststmt = 350, + RULE_opt_if_exists = 351, RULE_createtransformstmt = 352, RULE_transform_element_list = 353, + RULE_droptransformstmt = 354, RULE_reindexstmt = 355, RULE_reindex_target_type = 356, + RULE_reindex_target_multitable = 357, RULE_reindex_option_list = 358, + RULE_reindex_option_elem = 359, RULE_altertblspcstmt = 360, RULE_renamestmt = 361, + RULE_opt_column = 362, RULE_opt_set_data = 363, RULE_alterobjectdependsstmt = 364, + RULE_opt_no = 365, RULE_alterobjectschemastmt = 366, RULE_alteroperatorstmt = 367, + RULE_operator_def_list = 368, RULE_operator_def_elem = 369, RULE_operator_def_arg = 370, + RULE_altertypestmt = 371, RULE_alterownerstmt = 372, RULE_createpublicationstmt = 373, + RULE_opt_publication_for_tables = 374, RULE_publication_for_tables = 375, + RULE_alterpublicationstmt = 376, RULE_createsubscriptionstmt = 377, RULE_publication_name_list = 378, + RULE_publication_name_item = 379, RULE_altersubscriptionstmt = 380, RULE_dropsubscriptionstmt = 381, + RULE_rulestmt = 382, RULE_ruleactionlist = 383, RULE_ruleactionmulti = 384, + RULE_ruleactionstmt = 385, RULE_ruleactionstmtOrEmpty = 386, RULE_event = 387, + RULE_opt_instead = 388, RULE_notifystmt = 389, RULE_notify_payload = 390, + RULE_listenstmt = 391, RULE_unlistenstmt = 392, RULE_transactionstmt = 393, + RULE_opt_transaction = 394, RULE_transaction_mode_item = 395, RULE_transaction_mode_list = 396, + RULE_transaction_mode_list_or_empty = 397, RULE_opt_transaction_chain = 398, + RULE_viewstmt = 399, RULE_opt_check_option = 400, RULE_loadstmt = 401, + RULE_createdbstmt = 402, RULE_createdb_opt_list = 403, RULE_createdb_opt_items = 404, + RULE_createdb_opt_item = 405, RULE_createdb_opt_name = 406, RULE_opt_equal = 407, + RULE_alterdatabasestmt = 408, RULE_alterdatabasesetstmt = 409, RULE_dropdbstmt = 410, + RULE_drop_option_list = 411, RULE_drop_option = 412, RULE_altercollationstmt = 413, + RULE_altersystemstmt = 414, RULE_createdomainstmt = 415, RULE_alterdomainstmt = 416, + RULE_opt_as = 417, RULE_altertsdictionarystmt = 418, RULE_altertsconfigurationstmt = 419, + RULE_any_with = 420, RULE_createconversionstmt = 421, RULE_clusterstmt = 422, + RULE_cluster_index_specification = 423, RULE_vacuumstmt = 424, RULE_analyzestmt = 425, + RULE_vac_analyze_option_list = 426, RULE_analyze_keyword = 427, RULE_vac_analyze_option_elem = 428, + RULE_vac_analyze_option_name = 429, RULE_vac_analyze_option_arg = 430, + RULE_opt_analyze = 431, RULE_opt_verbose = 432, RULE_opt_full = 433, RULE_opt_freeze = 434, + RULE_opt_name_list = 435, RULE_vacuum_relation = 436, RULE_vacuum_relation_list = 437, + RULE_opt_vacuum_relation_list = 438, RULE_explainstmt = 439, RULE_explainablestmt = 440, + RULE_explain_option_list = 441, RULE_explain_option_elem = 442, RULE_explain_option_name = 443, + RULE_explain_option_arg = 444, RULE_preparestmt = 445, RULE_prep_type_clause = 446, + RULE_preparablestmt = 447, RULE_executestmt = 448, RULE_execute_param_clause = 449, + RULE_deallocatestmt = 450, RULE_insertstmt = 451, RULE_insert_target = 452, + RULE_insert_rest = 453, RULE_override_kind = 454, RULE_insert_column_list = 455, + RULE_insert_column_item = 456, RULE_opt_on_conflict = 457, RULE_opt_conf_expr = 458, + RULE_returning_clause = 459, RULE_mergestmt = 460, RULE_merge_insert_clause = 461, + RULE_merge_update_clause = 462, RULE_merge_delete_clause = 463, RULE_deletestmt = 464, + RULE_using_clause = 465, RULE_lockstmt = 466, RULE_opt_lock = 467, RULE_lock_type = 468, + RULE_opt_nowait = 469, RULE_opt_nowait_or_skip = 470, RULE_updatestmt = 471, + RULE_set_clause_list = 472, RULE_set_clause = 473, RULE_set_target = 474, + RULE_set_target_list = 475, RULE_declarecursorstmt = 476, RULE_cursor_name = 477, + RULE_cursor_options = 478, RULE_opt_hold = 479, RULE_selectstmt = 480, + RULE_select_with_parens = 481, RULE_select_no_parens = 482, RULE_select_clause = 483, + RULE_simple_select_intersect = 484, RULE_simple_select_pramary = 485, + RULE_top_clause = 486, RULE_with_clause = 487, RULE_cte_list = 488, RULE_common_table_expr = 489, + RULE_opt_materialized = 490, RULE_opt_with_clause = 491, RULE_into_clause = 492, + RULE_opt_strict = 493, RULE_opttempTableName = 494, RULE_opt_table = 495, + RULE_all_or_distinct = 496, RULE_distinct_clause = 497, RULE_opt_all_clause = 498, + RULE_opt_sort_clause = 499, RULE_sort_clause = 500, RULE_sortby_list = 501, + RULE_sortby = 502, RULE_select_limit = 503, RULE_opt_select_limit = 504, + RULE_limit_clause = 505, RULE_offset_clause = 506, RULE_select_limit_value = 507, + RULE_select_offset_value = 508, RULE_select_fetch_first_value = 509, RULE_i_or_f_const = 510, + RULE_row_or_rows = 511, RULE_first_or_next = 512, RULE_group_clause = 513, + RULE_group_by_list = 514, RULE_group_by_item = 515, RULE_empty_grouping_set = 516, + RULE_rollup_clause = 517, RULE_cube_clause = 518, RULE_grouping_sets_clause = 519, + RULE_having_clause = 520, RULE_for_locking_clause = 521, RULE_opt_for_locking_clause = 522, + RULE_for_locking_items = 523, RULE_for_locking_item = 524, RULE_for_locking_strength = 525, + RULE_locked_rels_list = 526, RULE_values_clause = 527, RULE_from_clause = 528, + RULE_from_list = 529, RULE_non_ansi_join = 530, RULE_table_ref = 531, + RULE_alias_clause = 532, RULE_opt_alias_clause = 533, RULE_table_alias_clause = 534, + RULE_func_alias_clause = 535, RULE_join_type = 536, RULE_join_qual = 537, + RULE_relation_expr = 538, RULE_relation_expr_list = 539, RULE_relation_expr_opt_alias = 540, + RULE_tablesample_clause = 541, RULE_opt_repeatable_clause = 542, RULE_func_table = 543, + RULE_rowsfrom_item = 544, RULE_rowsfrom_list = 545, RULE_opt_col_def_list = 546, + RULE_opt_ordinality = 547, RULE_where_clause = 548, RULE_where_or_current_clause = 549, + RULE_opttablefuncelementlist = 550, RULE_tablefuncelementlist = 551, RULE_tablefuncelement = 552, + RULE_xmltable = 553, RULE_xmltable_column_list = 554, RULE_xmltable_column_el = 555, + RULE_xmltable_column_option_list = 556, RULE_xmltable_column_option_el = 557, + RULE_xml_namespace_list = 558, RULE_xml_namespace_el = 559, RULE_typename = 560, + RULE_opt_array_bounds = 561, RULE_simpletypename = 562, RULE_consttypename = 563, + RULE_generictype = 564, RULE_opt_type_modifiers = 565, RULE_numeric = 566, + RULE_opt_float = 567, RULE_bit = 568, RULE_constbit = 569, RULE_bitwithlength = 570, + RULE_bitwithoutlength = 571, RULE_character = 572, RULE_constcharacter = 573, + RULE_character_c = 574, RULE_opt_varying = 575, RULE_constdatetime = 576, + RULE_constinterval = 577, RULE_opt_timezone = 578, RULE_opt_interval = 579, + RULE_interval_second = 580, RULE_opt_escape = 581, RULE_a_expr = 582, + RULE_a_expr_qual = 583, RULE_a_expr_lessless = 584, RULE_a_expr_or = 585, + RULE_a_expr_and = 586, RULE_a_expr_between = 587, RULE_a_expr_in = 588, + RULE_a_expr_unary_not = 589, RULE_a_expr_isnull = 590, RULE_a_expr_is_not = 591, + RULE_a_expr_compare = 592, RULE_a_expr_like = 593, RULE_a_expr_qual_op = 594, + RULE_a_expr_unary_qualop = 595, RULE_a_expr_add = 596, RULE_a_expr_mul = 597, + RULE_a_expr_caret = 598, RULE_a_expr_unary_sign = 599, RULE_a_expr_at_time_zone = 600, + RULE_a_expr_collate = 601, RULE_a_expr_typecast = 602, RULE_b_expr = 603, + RULE_c_expr = 604, RULE_func_application = 605, RULE_func_expr = 606, + RULE_func_expr_windowless = 607, RULE_func_expr_common_subexpr = 608, + RULE_xml_root_version = 609, RULE_opt_xml_root_standalone = 610, RULE_xml_attributes = 611, + RULE_xml_attribute_list = 612, RULE_xml_attribute_el = 613, RULE_document_or_content = 614, + RULE_xml_whitespace_option = 615, RULE_xmlexists_argument = 616, RULE_xml_passing_mech = 617, + RULE_within_group_clause = 618, RULE_filter_clause = 619, RULE_window_clause = 620, + RULE_window_definition_list = 621, RULE_window_definition = 622, RULE_over_clause = 623, + RULE_window_specification = 624, RULE_opt_existing_window_name = 625, + RULE_opt_partition_clause = 626, RULE_opt_frame_clause = 627, RULE_frame_extent = 628, + RULE_frame_bound = 629, RULE_opt_window_exclusion_clause = 630, RULE_row = 631, + RULE_explicit_row = 632, RULE_implicit_row = 633, RULE_sub_type = 634, + RULE_all_op = 635, RULE_mathop = 636, RULE_qual_op = 637, RULE_qual_all_op = 638, + RULE_subquery_Op = 639, RULE_expr_list = 640, RULE_func_arg_list = 641, + RULE_func_arg_expr = 642, RULE_type_list = 643, RULE_array_expr = 644, + RULE_array_expr_list = 645, RULE_extract_list = 646, RULE_extract_arg = 647, + RULE_unicode_normal_form = 648, RULE_overlay_list = 649, RULE_position_list = 650, + RULE_substr_list = 651, RULE_trim_list = 652, RULE_in_expr = 653, RULE_case_expr = 654, + RULE_when_clause_list = 655, RULE_when_clause = 656, RULE_case_default = 657, + RULE_case_arg = 658, RULE_columnref = 659, RULE_indirection_el = 660, + RULE_opt_slice_bound = 661, RULE_indirection = 662, RULE_opt_indirection = 663, + RULE_opt_target_list = 664, RULE_target_list = 665, RULE_target_el = 666, + RULE_qualified_name_list = 667, RULE_qualified_name = 668, RULE_name_list = 669, + RULE_name = 670, RULE_attr_name = 671, RULE_file_name = 672, RULE_func_name = 673, + RULE_aexprconst = 674, RULE_xconst = 675, RULE_bconst = 676, RULE_fconst = 677, + RULE_iconst = 678, RULE_sconst = 679, RULE_anysconst = 680, RULE_opt_uescape = 681, + RULE_signediconst = 682, RULE_roleid = 683, RULE_rolespec = 684, RULE_role_list = 685, + RULE_colid = 686, RULE_table_alias = 687, RULE_type_function_name = 688, + RULE_nonreservedword = 689, RULE_collabel = 690, RULE_identifier = 691, + RULE_plsqlidentifier = 692, RULE_unreserved_keyword = 693, RULE_col_name_keyword = 694, + RULE_type_func_name_keyword = 695, RULE_reserved_keyword = 696, RULE_builtin_function_name = 697, + RULE_pl_function = 698, RULE_comp_options = 699, RULE_comp_option = 700, + RULE_sharp = 701, RULE_option_value = 702, RULE_opt_semi = 703, RULE_pl_block = 704, + RULE_decl_sect = 705, RULE_decl_start = 706, RULE_decl_stmts = 707, RULE_label_decl = 708, + RULE_decl_stmt = 709, RULE_decl_statement = 710, RULE_opt_scrollable = 711, + RULE_decl_cursor_query = 712, RULE_decl_cursor_args = 713, RULE_decl_cursor_arglist = 714, + RULE_decl_cursor_arg = 715, RULE_decl_is_for = 716, RULE_decl_aliasitem = 717, + RULE_decl_varname = 718, RULE_decl_const = 719, RULE_decl_datatype = 720, + RULE_decl_collate = 721, RULE_decl_notnull = 722, RULE_decl_defval = 723, + RULE_decl_defkey = 724, RULE_assign_operator = 725, RULE_proc_sect = 726, + RULE_proc_stmt = 727, RULE_stmt_perform = 728, RULE_stmt_call = 729, RULE_opt_expr_list = 730, + RULE_stmt_assign = 731, RULE_stmt_getdiag = 732, RULE_getdiag_area_opt = 733, + RULE_getdiag_list = 734, RULE_getdiag_list_item = 735, RULE_getdiag_item = 736, + RULE_getdiag_target = 737, RULE_assign_var = 738, RULE_stmt_if = 739, + RULE_stmt_elsifs = 740, RULE_stmt_else = 741, RULE_stmt_case = 742, RULE_opt_expr_until_when = 743, + RULE_case_when_list = 744, RULE_case_when = 745, RULE_opt_case_else = 746, + RULE_stmt_loop = 747, RULE_stmt_while = 748, RULE_stmt_for = 749, RULE_for_control = 750, + RULE_opt_for_using_expression = 751, RULE_opt_cursor_parameters = 752, + RULE_opt_reverse = 753, RULE_opt_by_expression = 754, RULE_for_variable = 755, + RULE_stmt_foreach_a = 756, RULE_foreach_slice = 757, RULE_stmt_exit = 758, + RULE_exit_type = 759, RULE_stmt_return = 760, RULE_opt_return_result = 761, + RULE_stmt_raise = 762, RULE_opt_stmt_raise_level = 763, RULE_opt_raise_list = 764, + RULE_opt_raise_using = 765, RULE_opt_raise_using_elem = 766, RULE_opt_raise_using_elem_list = 767, + RULE_stmt_assert = 768, RULE_opt_stmt_assert_message = 769, RULE_loop_body = 770, + RULE_stmt_execsql = 771, RULE_stmt_dynexecute = 772, RULE_opt_execute_using = 773, + RULE_opt_execute_using_list = 774, RULE_opt_execute_into = 775, RULE_stmt_open = 776, + RULE_opt_open_bound_list_item = 777, RULE_opt_open_bound_list = 778, RULE_opt_open_using = 779, + RULE_opt_scroll_option = 780, RULE_opt_scroll_option_no = 781, RULE_stmt_fetch = 782, + RULE_into_target = 783, RULE_opt_cursor_from = 784, RULE_opt_fetch_direction = 785, + RULE_stmt_move = 786, RULE_stmt_close = 787, RULE_stmt_null = 788, RULE_stmt_commit = 789, + RULE_stmt_rollback = 790, RULE_plsql_opt_transaction_chain = 791, RULE_stmt_set = 792, + RULE_cursor_variable = 793, RULE_exception_sect = 794, RULE_proc_exceptions = 795, + RULE_proc_exception = 796, RULE_proc_conditions = 797, RULE_proc_condition = 798, + RULE_opt_block_label = 799, RULE_opt_loop_label = 800, RULE_opt_label = 801, + RULE_opt_exitcond = 802, RULE_any_identifier = 803, RULE_plsql_unreserved_keyword = 804, + RULE_sql_expression = 805, RULE_expr_until_then = 806, RULE_expr_until_semi = 807, + RULE_expr_until_rightbracket = 808, RULE_expr_until_loop = 809, RULE_make_execsql_stmt = 810, + RULE_opt_returning_clause_into = 811, RULE_parameter = 812; private static String[] makeRuleNames() { return new String[] { - "root", "stmt", "abort_stmt", "alter_stmt", "alter_aggregate_stmt", "alter_collation_stmt", - "alter_conversion_stmt", "alter_database_stmt", "alter_default_privileges_stmt", - "alter_domain_stmt", "alter_event_trigger_stmt", "alter_extension_stmt", - "alter_foreign_data_wrapper_stmt", "alter_foreign_table_action", "alter_foreign_table_action_list", - "alter_foreign_table_stmt", "alter_function_stmt", "alter_group_stmt", - "alter_index_stmt", "alter_language_stmt", "alter_large_object_stmt", - "alter_materialize_view_stmt", "alter_operator_stmt", "alter_operator_class_stmt", - "alter_operator_family_stmt", "alter_policy_stmt", "alter_publication_stmt", - "alter_role_options", "alter_role_stmt", "alter_rule_stmt", "alter_schema_stmt", - "alter_sequence_stmt", "alter_server_options_list", "alter_server_stmt", - "alter_statistics_stmt", "alter_subscription_stmt", "alter_system_stmt", - "alter_table_stmt", "alter_tablespace_stmt", "alter_text_search_config_stmt", - "alter_text_search_dict_stmt", "alter_text_search_parser_stmt", "alter_text_search_template_stmt", - "alter_trigger_stmt", "alter_type_stmt", "alter_user_stmt", "alter_user_mapping_stmt", - "alter_view_stmt", "analyze_stmt", "close_stmt", "cluster_stmt", "comment_stmt", - "commit_stmt", "commit_prepared_stmt", "copy_stmt", "create_stmt", "create_access_method_stmt", - "create_aggregate_stmt", "create_cast_stmt", "create_collation_opt", - "create_collation_opt_list", "create_collation_stmt", "create_conversion_stmt", - "create_database_stmt", "domain_constraint", "create_domain_stmt", "create_event_trigger_cond", - "create_event_trigger_stmt", "create_foreign_data_options", "create_foreign_data_stmt", - "create_foreign_table_stmt", "create_function_stmt", "create_group_stmt", - "create_index_stmt", "create_language_stmt", "create_materialized_view_stmt", - "create_operator_stmt", "create_operator_class_opt", "create_operator_class_stmt", - "create_operator_family_stmt", "create_policy_stmt", "create_role_stmt", - "create_rule_event", "create_rule_stmt", "create_schema_stmt", "create_sequence_stmt", - "create_server_stmt", "create_statistics_stmt", "create_subscription_stmt", - "create_table_stmt", "create_table_as_stmt", "create_tablespace_stmt", - "create_text_search_config_stmt", "create_text_search_dict_stmt", "create_text_search_parser_stmt", - "create_text_search_template_stmt", "create_transform_stmt", "create_trigger_stmt", - "create_type_stmt", "create_user_stmt", "create_user_mapping_stmt", "create_view_stmt", - "deallocate_stmt", "declare_stmt", "delete_stmt", "discard_stmt", "drop_stmt", - "drop_access_method_stmt", "drop_aggregate_stmt", "drop_cast_stmt", "drop_collation_stmt", - "drop_conversion_stmt", "drop_database_stmt", "drop_domain_stmt", "drop_event_trigger_stmt", - "drop_extension_stmt", "drop_foreign_data_wrapper_stmt", "drop_foreign_table_stmt", - "drop_function_stmt", "drop_group_stmt", "drop_index_stmt", "drop_language_stmt", - "drop_materialized_view_stmt", "drop_operator_stmt", "drop_operator_class_stmt", - "drop_operator_family_stmt", "drop_owned_stmt", "drop_policy_stmt", "drop_publication_stmt", - "drop_role_stmt", "drop_rule_stmt", "drop_schema_stmt", "drop_sequence_stmt", - "drop_server_stmt", "drop_statistics_stmt", "drop_subscription_stmt", - "drop_table_stmt", "drop_tablespace_stmt", "drop_text_search_config_stmt", - "drop_text_search_dict_stmt", "drop_text_search_parser_stmt", "drop_text_search_template_stmt", - "drop_transform_stmt", "drop_trigger_stmt", "drop_type_stmt", "drop_user_stmt", - "drop_user_mapping_stmt", "drop_view_stmt", "execute_stmt", "explain_stmt", - "fetch_stmt", "grant_stmt", "import_foreign_schema_stmt", "insert_stmt", - "listen_stmt", "load_stmt", "lock_stmt", "move_stmt", "notify_stmt", - "prepare_stmt", "prepare_transaction_stmt", "reassign_owned_stmt", "refresh_materialized_view_stmt", - "reindex_stmt", "release_savepoint_stmt", "reset_stmt", "revoke_stmt", - "rollback_stmt", "rollback_prepared_stmt", "rollback_to_savepoint_stmt", - "savepoint_stmt", "security_label_stmt", "select_stmt", "select_into_stmt", - "with_clause", "with_expr", "set_stmt", "set_constraints_stmt", "set_role_stmt", - "set_session_authorization_stmt", "transaction_mode", "transaction_mode_list", - "set_transaction_stmt", "show_stmt", "truncate_stmt", "unlisten_stmt", - "update_stmt", "vacuum_opt", "vacuum_opt_list", "vacuum_stmt", "values_stmt", - "selector_clause", "from_clause", "where_clause", "group_by_clause", - "grouping_elem", "grouping_elem_list", "having_clause", "column_list", - "explain_parameter", "frame", "frame_start", "frame_end", "frame_clause", - "window_definition_list", "window_definition", "window_clause", "window_specification", - "partition_clause", "over_clause", "combine_clause", "order_by_clause", - "order_by_item", "limit_clause", "offset_clause", "fetch_clause", "for_clause", - "updater_clause", "updater_expr", "returning_clause", "expr", "parameter", - "parameterOrIntegerLiteral", "parameterOrNumericLiteral", "bool_expr", - "case_expr", "expr_list", "expr_list_list", "func_sig_arg", "func_sig_arg_list", - "func_sig", "func_sig_list", "type_name", "timezone", "oper", "aggregate", - "name_", "name_list", "identifier_list", "option_expr", "option_list", - "table_name_", "data_type", "data_type_list", "index_method", "func_name", - "func_call", "array_cons_expr", "from_item", "with_column_alias", "join_type", - "join_clause", "predicate", "aggregate_signature", "column_constraint", - "column_constraints", "index_parameters", "exclude_element", "table_constraint", - "role_name", "role_name_list", "param_value", "reserved_keyword", "non_reserved_keyword", - "identifier", "todo_fill_in", "todo_implement", "correlation_name", "column_name", - "alias", "column_alias", "column_definition", "window_name" + "root", "plsqlroot", "stmtblock", "stmtmulti", "stmt", "plsqlconsolecommand", + "callstmt", "createrolestmt", "opt_with", "optrolelist", "alteroptrolelist", + "alteroptroleelem", "createoptroleelem", "createuserstmt", "alterrolestmt", + "opt_in_database", "alterrolesetstmt", "droprolestmt", "creategroupstmt", + "altergroupstmt", "add_drop", "createschemastmt", "optschemaname", "optschemaeltlist", + "schema_stmt", "variablesetstmt", "set_rest", "generic_set", "set_rest_more", + "var_name", "var_list", "var_value", "iso_level", "opt_boolean_or_string", + "zone_value", "opt_encoding", "nonreservedword_or_sconst", "variableresetstmt", + "reset_rest", "generic_reset", "setresetclause", "functionsetresetclause", + "variableshowstmt", "constraintssetstmt", "constraints_set_list", "constraints_set_mode", + "checkpointstmt", "discardstmt", "altertablestmt", "alter_table_cmds", + "partition_cmd", "index_partition_cmd", "alter_table_cmd", "alter_column_default", + "opt_drop_behavior", "opt_collate_clause", "alter_using", "replica_identity", + "reloptions", "opt_reloptions", "reloption_list", "reloption_elem", "alter_identity_column_option_list", + "alter_identity_column_option", "partitionboundspec", "hash_partbound_elem", + "hash_partbound", "altercompositetypestmt", "alter_type_cmds", "alter_type_cmd", + "closeportalstmt", "copystmt", "copy_from", "opt_program", "copy_file_name", + "copy_options", "copy_opt_list", "copy_opt_item", "opt_binary", "copy_delimiter", + "opt_using", "copy_generic_opt_list", "copy_generic_opt_elem", "copy_generic_opt_arg", + "copy_generic_opt_arg_list", "copy_generic_opt_arg_list_item", "createstmt", + "opttemp", "opttableelementlist", "opttypedtableelementlist", "tableelementlist", + "typedtableelementlist", "tableelement", "typedtableelement", "columnDef", + "columnOptions", "colquallist", "colconstraint", "colconstraintelem", + "generated_when", "constraintattr", "tablelikeclause", "tablelikeoptionlist", + "tablelikeoption", "tableconstraint", "constraintelem", "opt_no_inherit", + "opt_column_list", "columnlist", "columnElem", "opt_c_include", "key_match", + "exclusionconstraintlist", "exclusionconstraintelem", "exclusionwhereclause", + "key_actions", "key_update", "key_delete", "key_action", "optinherit", + "optpartitionspec", "partitionspec", "part_params", "part_elem", "table_access_method_clause", + "optwith", "oncommitoption", "opttablespace", "optconstablespace", "existingindex", + "createstatsstmt", "alterstatsstmt", "createasstmt", "create_as_target", + "opt_with_data", "creatematviewstmt", "create_mv_target", "optnolog", + "refreshmatviewstmt", "createseqstmt", "alterseqstmt", "optseqoptlist", + "optparenthesizedseqoptlist", "seqoptlist", "seqoptelem", "opt_by", "numericonly", + "numericonly_list", "createplangstmt", "opt_trusted", "handler_name", + "opt_inline_handler", "validator_clause", "opt_validator", "opt_procedural", + "createtablespacestmt", "opttablespaceowner", "droptablespacestmt", "createextensionstmt", + "create_extension_opt_list", "create_extension_opt_item", "alterextensionstmt", + "alter_extension_opt_list", "alter_extension_opt_item", "alterextensioncontentsstmt", + "createfdwstmt", "fdw_option", "fdw_options", "opt_fdw_options", "alterfdwstmt", + "create_generic_options", "generic_option_list", "alter_generic_options", + "alter_generic_option_list", "alter_generic_option_elem", "generic_option_elem", + "generic_option_name", "generic_option_arg", "createforeignserverstmt", + "opt_type", "foreign_server_version", "opt_foreign_server_version", "alterforeignserverstmt", + "createforeigntablestmt", "importforeignschemastmt", "import_qualification_type", + "import_qualification", "createusermappingstmt", "auth_ident", "dropusermappingstmt", + "alterusermappingstmt", "createpolicystmt", "alterpolicystmt", "rowsecurityoptionalexpr", + "rowsecurityoptionalwithcheck", "rowsecuritydefaulttorole", "rowsecurityoptionaltorole", + "rowsecuritydefaultpermissive", "rowsecuritydefaultforcmd", "row_security_cmd", + "createamstmt", "am_type", "createtrigstmt", "triggeractiontime", "triggerevents", + "triggeroneevent", "triggerreferencing", "triggertransitions", "triggertransition", + "transitionoldornew", "transitionrowortable", "transitionrelname", "triggerforspec", + "triggerforopteach", "triggerfortype", "triggerwhen", "function_or_procedure", + "triggerfuncargs", "triggerfuncarg", "optconstrfromtable", "constraintattributespec", + "constraintattributeElem", "createeventtrigstmt", "event_trigger_when_list", + "event_trigger_when_item", "event_trigger_value_list", "altereventtrigstmt", + "enable_trigger", "createassertionstmt", "definestmt", "definition", + "def_list", "def_elem", "def_arg", "old_aggr_definition", "old_aggr_list", + "old_aggr_elem", "opt_enum_val_list", "enum_val_list", "alterenumstmt", + "opt_if_not_exists", "createopclassstmt", "opclass_item_list", "opclass_item", + "opt_default", "opt_opfamily", "opclass_purpose", "opt_recheck", "createopfamilystmt", + "alteropfamilystmt", "opclass_drop_list", "opclass_drop", "dropopclassstmt", + "dropopfamilystmt", "dropownedstmt", "reassignownedstmt", "dropstmt", + "object_type_any_name", "object_type_name", "drop_type_name", "object_type_name_on_any_name", + "any_name_list", "any_name", "attrs", "type_name_list", "truncatestmt", + "opt_restart_seqs", "commentstmt", "comment_text", "seclabelstmt", "opt_provider", + "security_label", "fetchstmt", "fetch_args", "from_in", "opt_from_in", + "grantstmt", "revokestmt", "privileges", "privilege_list", "privilege", + "privilege_target", "grantee_list", "grantee", "opt_grant_grant_option", + "grantrolestmt", "revokerolestmt", "opt_grant_admin_option", "opt_granted_by", + "alterdefaultprivilegesstmt", "defacloptionlist", "defacloption", "defaclaction", + "defacl_privilege_target", "indexstmt", "opt_unique", "opt_concurrently", + "opt_index_name", "access_method_clause", "index_params", "index_elem_options", + "index_elem", "opt_include", "index_including_params", "opt_collate", + "opt_class", "opt_asc_desc", "opt_nulls_order", "createfunctionstmt", + "opt_or_replace", "func_args", "func_args_list", "function_with_argtypes_list", + "function_with_argtypes", "func_args_with_defaults", "func_args_with_defaults_list", + "func_arg", "arg_class", "param_name", "func_return", "func_type", "func_arg_with_default", + "aggr_arg", "aggr_args", "aggr_args_list", "aggregate_with_argtypes", + "aggregate_with_argtypes_list", "createfunc_opt_list", "common_func_opt_item", + "createfunc_opt_item", "func_as", "transform_type_list", "opt_definition", + "table_func_column", "table_func_column_list", "alterfunctionstmt", "alterfunc_opt_list", + "opt_restrict", "removefuncstmt", "removeaggrstmt", "removeoperstmt", + "oper_argtypes", "any_operator", "operator_with_argtypes_list", "operator_with_argtypes", + "dostmt", "dostmt_opt_list", "dostmt_opt_item", "createcaststmt", "cast_context", + "dropcaststmt", "opt_if_exists", "createtransformstmt", "transform_element_list", + "droptransformstmt", "reindexstmt", "reindex_target_type", "reindex_target_multitable", + "reindex_option_list", "reindex_option_elem", "altertblspcstmt", "renamestmt", + "opt_column", "opt_set_data", "alterobjectdependsstmt", "opt_no", "alterobjectschemastmt", + "alteroperatorstmt", "operator_def_list", "operator_def_elem", "operator_def_arg", + "altertypestmt", "alterownerstmt", "createpublicationstmt", "opt_publication_for_tables", + "publication_for_tables", "alterpublicationstmt", "createsubscriptionstmt", + "publication_name_list", "publication_name_item", "altersubscriptionstmt", + "dropsubscriptionstmt", "rulestmt", "ruleactionlist", "ruleactionmulti", + "ruleactionstmt", "ruleactionstmtOrEmpty", "event", "opt_instead", "notifystmt", + "notify_payload", "listenstmt", "unlistenstmt", "transactionstmt", "opt_transaction", + "transaction_mode_item", "transaction_mode_list", "transaction_mode_list_or_empty", + "opt_transaction_chain", "viewstmt", "opt_check_option", "loadstmt", + "createdbstmt", "createdb_opt_list", "createdb_opt_items", "createdb_opt_item", + "createdb_opt_name", "opt_equal", "alterdatabasestmt", "alterdatabasesetstmt", + "dropdbstmt", "drop_option_list", "drop_option", "altercollationstmt", + "altersystemstmt", "createdomainstmt", "alterdomainstmt", "opt_as", "altertsdictionarystmt", + "altertsconfigurationstmt", "any_with", "createconversionstmt", "clusterstmt", + "cluster_index_specification", "vacuumstmt", "analyzestmt", "vac_analyze_option_list", + "analyze_keyword", "vac_analyze_option_elem", "vac_analyze_option_name", + "vac_analyze_option_arg", "opt_analyze", "opt_verbose", "opt_full", "opt_freeze", + "opt_name_list", "vacuum_relation", "vacuum_relation_list", "opt_vacuum_relation_list", + "explainstmt", "explainablestmt", "explain_option_list", "explain_option_elem", + "explain_option_name", "explain_option_arg", "preparestmt", "prep_type_clause", + "preparablestmt", "executestmt", "execute_param_clause", "deallocatestmt", + "insertstmt", "insert_target", "insert_rest", "override_kind", "insert_column_list", + "insert_column_item", "opt_on_conflict", "opt_conf_expr", "returning_clause", + "mergestmt", "merge_insert_clause", "merge_update_clause", "merge_delete_clause", + "deletestmt", "using_clause", "lockstmt", "opt_lock", "lock_type", "opt_nowait", + "opt_nowait_or_skip", "updatestmt", "set_clause_list", "set_clause", + "set_target", "set_target_list", "declarecursorstmt", "cursor_name", + "cursor_options", "opt_hold", "selectstmt", "select_with_parens", "select_no_parens", + "select_clause", "simple_select_intersect", "simple_select_pramary", + "top_clause", "with_clause", "cte_list", "common_table_expr", "opt_materialized", + "opt_with_clause", "into_clause", "opt_strict", "opttempTableName", "opt_table", + "all_or_distinct", "distinct_clause", "opt_all_clause", "opt_sort_clause", + "sort_clause", "sortby_list", "sortby", "select_limit", "opt_select_limit", + "limit_clause", "offset_clause", "select_limit_value", "select_offset_value", + "select_fetch_first_value", "i_or_f_const", "row_or_rows", "first_or_next", + "group_clause", "group_by_list", "group_by_item", "empty_grouping_set", + "rollup_clause", "cube_clause", "grouping_sets_clause", "having_clause", + "for_locking_clause", "opt_for_locking_clause", "for_locking_items", + "for_locking_item", "for_locking_strength", "locked_rels_list", "values_clause", + "from_clause", "from_list", "non_ansi_join", "table_ref", "alias_clause", + "opt_alias_clause", "table_alias_clause", "func_alias_clause", "join_type", + "join_qual", "relation_expr", "relation_expr_list", "relation_expr_opt_alias", + "tablesample_clause", "opt_repeatable_clause", "func_table", "rowsfrom_item", + "rowsfrom_list", "opt_col_def_list", "opt_ordinality", "where_clause", + "where_or_current_clause", "opttablefuncelementlist", "tablefuncelementlist", + "tablefuncelement", "xmltable", "xmltable_column_list", "xmltable_column_el", + "xmltable_column_option_list", "xmltable_column_option_el", "xml_namespace_list", + "xml_namespace_el", "typename", "opt_array_bounds", "simpletypename", + "consttypename", "generictype", "opt_type_modifiers", "numeric", "opt_float", + "bit", "constbit", "bitwithlength", "bitwithoutlength", "character", + "constcharacter", "character_c", "opt_varying", "constdatetime", "constinterval", + "opt_timezone", "opt_interval", "interval_second", "opt_escape", "a_expr", + "a_expr_qual", "a_expr_lessless", "a_expr_or", "a_expr_and", "a_expr_between", + "a_expr_in", "a_expr_unary_not", "a_expr_isnull", "a_expr_is_not", "a_expr_compare", + "a_expr_like", "a_expr_qual_op", "a_expr_unary_qualop", "a_expr_add", + "a_expr_mul", "a_expr_caret", "a_expr_unary_sign", "a_expr_at_time_zone", + "a_expr_collate", "a_expr_typecast", "b_expr", "c_expr", "func_application", + "func_expr", "func_expr_windowless", "func_expr_common_subexpr", "xml_root_version", + "opt_xml_root_standalone", "xml_attributes", "xml_attribute_list", "xml_attribute_el", + "document_or_content", "xml_whitespace_option", "xmlexists_argument", + "xml_passing_mech", "within_group_clause", "filter_clause", "window_clause", + "window_definition_list", "window_definition", "over_clause", "window_specification", + "opt_existing_window_name", "opt_partition_clause", "opt_frame_clause", + "frame_extent", "frame_bound", "opt_window_exclusion_clause", "row", + "explicit_row", "implicit_row", "sub_type", "all_op", "mathop", "qual_op", + "qual_all_op", "subquery_Op", "expr_list", "func_arg_list", "func_arg_expr", + "type_list", "array_expr", "array_expr_list", "extract_list", "extract_arg", + "unicode_normal_form", "overlay_list", "position_list", "substr_list", + "trim_list", "in_expr", "case_expr", "when_clause_list", "when_clause", + "case_default", "case_arg", "columnref", "indirection_el", "opt_slice_bound", + "indirection", "opt_indirection", "opt_target_list", "target_list", "target_el", + "qualified_name_list", "qualified_name", "name_list", "name", "attr_name", + "file_name", "func_name", "aexprconst", "xconst", "bconst", "fconst", + "iconst", "sconst", "anysconst", "opt_uescape", "signediconst", "roleid", + "rolespec", "role_list", "colid", "table_alias", "type_function_name", + "nonreservedword", "collabel", "identifier", "plsqlidentifier", "unreserved_keyword", + "col_name_keyword", "type_func_name_keyword", "reserved_keyword", "builtin_function_name", + "pl_function", "comp_options", "comp_option", "sharp", "option_value", + "opt_semi", "pl_block", "decl_sect", "decl_start", "decl_stmts", "label_decl", + "decl_stmt", "decl_statement", "opt_scrollable", "decl_cursor_query", + "decl_cursor_args", "decl_cursor_arglist", "decl_cursor_arg", "decl_is_for", + "decl_aliasitem", "decl_varname", "decl_const", "decl_datatype", "decl_collate", + "decl_notnull", "decl_defval", "decl_defkey", "assign_operator", "proc_sect", + "proc_stmt", "stmt_perform", "stmt_call", "opt_expr_list", "stmt_assign", + "stmt_getdiag", "getdiag_area_opt", "getdiag_list", "getdiag_list_item", + "getdiag_item", "getdiag_target", "assign_var", "stmt_if", "stmt_elsifs", + "stmt_else", "stmt_case", "opt_expr_until_when", "case_when_list", "case_when", + "opt_case_else", "stmt_loop", "stmt_while", "stmt_for", "for_control", + "opt_for_using_expression", "opt_cursor_parameters", "opt_reverse", "opt_by_expression", + "for_variable", "stmt_foreach_a", "foreach_slice", "stmt_exit", "exit_type", + "stmt_return", "opt_return_result", "stmt_raise", "opt_stmt_raise_level", + "opt_raise_list", "opt_raise_using", "opt_raise_using_elem", "opt_raise_using_elem_list", + "stmt_assert", "opt_stmt_assert_message", "loop_body", "stmt_execsql", + "stmt_dynexecute", "opt_execute_using", "opt_execute_using_list", "opt_execute_into", + "stmt_open", "opt_open_bound_list_item", "opt_open_bound_list", "opt_open_using", + "opt_scroll_option", "opt_scroll_option_no", "stmt_fetch", "into_target", + "opt_cursor_from", "opt_fetch_direction", "stmt_move", "stmt_close", + "stmt_null", "stmt_commit", "stmt_rollback", "plsql_opt_transaction_chain", + "stmt_set", "cursor_variable", "exception_sect", "proc_exceptions", "proc_exception", + "proc_conditions", "proc_condition", "opt_block_label", "opt_loop_label", + "opt_label", "opt_exitcond", "any_identifier", "plsql_unreserved_keyword", + "sql_expression", "expr_until_then", "expr_until_semi", "expr_until_rightbracket", + "expr_until_loop", "make_execsql_stmt", "opt_returning_clause_into", + "parameter" }; } public static final String[] ruleNames = makeRuleNames(); private static String[] makeLiteralNames() { return new String[] { + null, null, "'$'", "'('", "')'", "'['", "']'", "','", "';'", "':'", "'?'", + "'*'", "'='", "'.'", "'+'", "'-'", "'/'", "'^'", "'<'", "'>'", "'<<'", + "'>>'", "':='", "'<='", "'=>'", "'>='", "'..'", "'<>'", "'::'", "'%'", + null, null, "'ALL'", "'ANALYSE'", "'ANALYZE'", "'AND'", "'ANY'", "'ARRAY'", + "'AS'", "'ASC'", "'ASYMMETRIC'", "'BOTH'", "'CASE'", "'CAST'", "'CHECK'", + "'COLLATE'", "'COLUMN'", "'CONSTRAINT'", "'CREATE'", "'CURRENT_CATALOG'", + "'CURRENT_DATE'", "'CURRENT_ROLE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_USER'", "'DEFAULT'", "'DEFERRABLE'", "'DESC'", "'DISTINCT'", + "'DO'", "'ELSE'", "'EXCEPT'", "'FALSE'", "'FETCH'", "'FOR'", "'FOREIGN'", + "'FROM'", "'GRANT'", "'GROUP'", "'HAVING'", "'IN'", "'INITIALLY'", "'INTERSECT'", + "'INTO'", "'LATERAL'", "'LEADING'", "'LIMIT'", "'LOCALTIME'", "'LOCALTIMESTAMP'", + "'NOT'", "'NULL'", "'OFFSET'", "'ON'", "'ONLY'", "'OR'", "'ORDER'", "'PLACING'", + "'PRIMARY'", "'REFERENCES'", "'RETURNING'", "'SELECT'", "'SESSION_USER'", + "'SOME'", "'SYMMETRIC'", "'TABLE'", "'THEN'", "'TO'", "'TRAILING'", "'TRUE'", + "'UNION'", "'UNIQUE'", "'USER'", "'USING'", "'VARIADIC'", "'WHEN'", "'WHERE'", + "'WINDOW'", "'WITH'", "'AUTHORIZATION'", "'BINARY'", "'COLLATION'", "'CONCURRENTLY'", + "'CROSS'", "'CURRENT_SCHEMA'", "'FREEZE'", "'FULL'", "'ILIKE'", "'INNER'", + "'IS'", "'ISNULL'", "'JOIN'", "'LEFT'", "'LIKE'", "'NATURAL'", "'NOTNULL'", + "'OUTER'", "'OVER'", "'OVERLAPS'", "'RIGHT'", "'SIMILAR'", "'VERBOSE'", + "'ABORT'", "'ABSOLUTE'", "'ACCESS'", "'ACTION'", "'ADD'", "'ADMIN'", + "'AFTER'", "'AGGREGATE'", "'ALSO'", "'ALTER'", "'ALWAYS'", "'ASSERTION'", + "'ASSIGNMENT'", "'AT'", "'ATTRIBUTE'", "'BACKWARD'", "'BEFORE'", "'BEGIN'", + "'BY'", "'CACHE'", "'CALLED'", "'CASCADE'", "'CASCADED'", "'CATALOG'", + "'CHAIN'", "'CHARACTERISTICS'", "'CHECKPOINT'", "'CLASS'", "'CLOSE'", + "'CLUSTER'", "'COMMENT'", "'COMMENTS'", "'COMMIT'", "'COMMITTED'", "'CONFIGURATION'", + "'CONNECTION'", "'CONSTRAINTS'", "'CONTENT'", "'CONTINUE'", "'CONVERSION'", + "'COPY'", "'COST'", "'CSV'", "'CURSOR'", "'CYCLE'", "'DATA'", "'DATABASE'", + "'DAY'", "'DEALLOCATE'", "'DECLARE'", "'DEFAULTS'", "'DEFERRED'", "'DEFINER'", + "'DELETE'", "'DELIMITER'", "'DELIMITERS'", "'DICTIONARY'", "'DISABLE'", + "'DISCARD'", "'DOCUMENT'", "'DOMAIN'", "'DOUBLE'", "'DROP'", "'EACH'", + "'ENABLE'", "'ENCODING'", "'ENCRYPTED'", "'ENUM'", "'ESCAPE'", "'EVENT'", + "'EXCLUDE'", "'EXCLUDING'", "'EXCLUSIVE'", "'EXECUTE'", "'EXPLAIN'", + "'EXTENSION'", "'EXTERNAL'", "'FAMILY'", "'FIRST'", "'FOLLOWING'", "'FORCE'", + "'FORWARD'", "'FUNCTION'", "'FUNCTIONS'", "'GLOBAL'", "'GRANTED'", "'HANDLER'", + "'HEADER'", "'HOLD'", "'HOUR'", "'IDENTITY'", "'IF'", "'IMMEDIATE'", + "'IMMUTABLE'", "'IMPLICIT'", "'INCLUDING'", "'INCREMENT'", "'INDEX'", + "'INDEXES'", "'INHERIT'", "'INHERITS'", "'INLINE'", "'INSENSITIVE'", + "'INSERT'", "'INSTEAD'", "'INVOKER'", "'ISOLATION'", "'KEY'", "'LABEL'", + "'LANGUAGE'", "'LARGE'", "'LAST'", "'LEAKPROOF'", "'LEVEL'", "'LISTEN'", + "'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", "'MAPPING'", "'MATCH'", + "'MATCHED'", "'MATERIALIZED'", "'MAXVALUE'", "'MERGE'", "'MINUTE'", "'MINVALUE'", + "'MODE'", "'MONTH'", "'MOVE'", "'NAME'", "'NAMES'", "'NEXT'", "'NO'", + "'NOTHING'", "'NOTIFY'", "'NOWAIT'", "'NULLS'", "'OBJECT'", "'OF'", "'OFF'", + "'OIDS'", "'OPERATOR'", "'OPTION'", "'OPTIONS'", "'OWNED'", "'OWNER'", + "'PARSER'", "'PARTIAL'", "'PARTITION'", "'PASSING'", "'PASSWORD'", "'PLANS'", + "'PRECEDING'", "'PREPARE'", "'PREPARED'", "'PRESERVE'", "'PRIOR'", "'PRIVILEGES'", + "'PROCEDURAL'", "'PROCEDURE'", "'PROGRAM'", "'QUOTE'", "'RANGE'", "'READ'", + "'REASSIGN'", "'RECHECK'", "'RECURSIVE'", "'REF'", "'REFRESH'", "'REINDEX'", + "'RELATIVE'", "'RELEASE'", "'RENAME'", "'REPEATABLE'", "'REPLACE'", "'REPLICA'", + "'RESET'", "'RESTART'", "'RESTRICT'", "'RETURNS'", "'REVOKE'", "'ROLE'", + "'ROLLBACK'", "'ROWS'", "'RULE'", "'SAVEPOINT'", "'SCHEMA'", "'SCROLL'", + "'SEARCH'", "'SECOND'", "'SECURITY'", "'SEQUENCE'", "'SEQUENCES'", "'SERIALIZABLE'", + "'SERVER'", "'SESSION'", "'SET'", "'SHARE'", "'SHOW'", "'SIMPLE'", "'SNAPSHOT'", + "'STABLE'", "'STANDALONE'", "'START'", "'STATEMENT'", "'STATISTICS'", + "'STDIN'", "'STDOUT'", "'STORAGE'", "'STRICT'", "'STRIP'", "'SYSID'", + "'SYSTEM'", "'TABLES'", "'TABLESPACE'", "'TEMP'", "'TEMPLATE'", "'TEMPORARY'", + "'TEXT'", "'TRANSACTION'", "'TRIGGER'", "'TRUNCATE'", "'TRUSTED'", "'TYPE'", + "'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", "'UNENCRYPTED'", "'UNKNOWN'", + "'UNLISTEN'", "'UNLOGGED'", "'UNTIL'", "'UPDATE'", "'VACUUM'", "'VALID'", + "'VALIDATE'", "'VALIDATOR'", "'VARYING'", "'VERSION'", "'VIEW'", "'VOLATILE'", + "'WHITESPACE'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'WRITE'", "'XML'", + "'YEAR'", "'YES'", "'ZONE'", "'BETWEEN'", "'BIGINT'", "'BIT'", "'BOOLEAN'", + "'CHAR'", "'CHARACTER'", "'COALESCE'", "'DEC'", "'DECIMAL'", "'EXISTS'", + "'EXTRACT'", "'FLOAT'", "'GREATEST'", "'INOUT'", "'INT'", "'INTEGER'", + "'INTERVAL'", "'LEAST'", "'NATIONAL'", "'NCHAR'", "'NONE'", "'NULLIF'", + "'NUMERIC'", "'OVERLAY'", "'POSITION'", "'PRECISION'", "'REAL'", "'ROW'", + "'SETOF'", "'SMALLINT'", "'SUBSTRING'", "'TIME'", "'TIMESTAMP'", "'TREAT'", + "'TRIM'", "'VALUES'", "'VARCHAR'", "'XMLATTRIBUTES'", "'XMLCOMMENT'", + "'XMLAGG'", "'XML_IS_WELL_FORMED'", "'XML_IS_WELL_FORMED_DOCUMENT'", + "'XML_IS_WELL_FORMED_CONTENT'", "'XPATH'", "'XPATH_EXISTS'", "'XMLCONCAT'", + "'XMLELEMENT'", "'XMLEXISTS'", "'XMLFOREST'", "'XMLPARSE'", "'XMLPI'", + "'XMLROOT'", "'XMLSERIALIZE'", "'CALL'", "'CURRENT'", "'ATTACH'", "'DETACH'", + "'EXPRESSION'", "'GENERATED'", "'LOGGED'", "'STORED'", "'INCLUDE'", "'ROUTINE'", + "'TRANSFORM'", "'IMPORT'", "'POLICY'", "'METHOD'", "'REFERENCING'", "'NEW'", + "'OLD'", "'VALUE'", "'SUBSCRIPTION'", "'PUBLICATION'", "'OUT'", "'END'", + "'ROUTINES'", "'SCHEMAS'", "'PROCEDURES'", "'INPUT'", "'SUPPORT'", "'PARALLEL'", + "'SQL'", "'DEPENDS'", "'OVERRIDING'", "'CONFLICT'", "'SKIP'", "'LOCKED'", + "'TIES'", "'ROLLUP'", "'CUBE'", "'GROUPING'", "'SETS'", "'TABLESAMPLE'", + "'ORDINALITY'", "'XMLTABLE'", "'COLUMNS'", "'XMLNAMESPACES'", "'ROWTYPE'", + "'NORMALIZED'", "'WITHIN'", "'FILTER'", "'GROUPS'", "'OTHERS'", "'NFC'", + "'NFD'", "'NFKC'", "'NFKD'", "'UESCAPE'", "'VIEWS'", "'NORMALIZE'", "'DUMP'", + "'PRINT_STRICT_PARAMS'", "'VARIABLE_CONFLICT'", "'ERROR'", "'USE_VARIABLE'", + "'USE_COLUMN'", "'ALIAS'", "'CONSTANT'", "'PERFORM'", "'GET'", "'DIAGNOSTICS'", + "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'", "'FOREACH'", "'SLICE'", + "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'", "'SQLSTATE'", "'DEBUG'", + "'LOG'", "'INFO'", "'NOTICE'", "'WARNING'", "'EXCEPTION'", "'ASSERT'", + "'LOOP'", "'OPEN'", "'TOP'", "'ABS'", "'CBRT'", "'CEIL'", "'CEILING'", + "'DEGREES'", "'DIV'", "'EXP'", "'FACTORIAL'", "'FLOOR'", "'GCD'", "'LCM'", + "'LN'", "'LOG10'", "'MIN_SCALE'", "'MOD'", "'PI'", "'POWER'", "'RADIANS'", + "'ROUND'", "'SCALE'", "'SIGN'", "'SQRT'", "'TRIM_SCALE'", "'TRUNC'", + "'WIDTH_BUCKET'", "'RANDOM'", "'SETSEED'", "'ACOS'", "'ACOSD'", "'ASIN'", + "'ASIND'", "'ATAN'", "'ATAND'", "'ATAN2'", "'ATAN2D'", "'COS'", "'COSD'", + "'COT'", "'COTD'", "'SIN'", "'SIND'", "'TAN'", "'TAND'", "'SINH'", "'COSH'", + "'TANH'", "'ASINH'", "'ACOSH'", "'ATANH'", "'BIT_LENGTH'", "'CHAR_LENGTH'", + "'CHARACTER_LENGTH'", "'LOWER'", "'OCTET_LENGTH'", "'UPPER'", "'ASCII'", + "'BTRIM'", "'CHR'", "'CONCAT'", "'CONCAT_WS'", "'FORMAT'", "'INITCAP'", + "'LENGTH'", "'LPAD'", "'LTRIM'", "'MD5'", "'PARSE_IDENT'", "'PG_CLIENT_ENCODING'", + "'QUOTE_IDENT'", "'QUOTE_LITERAL'", "'QUOTE_NULLABLE'", "'REGEXP_COUNT'", + "'REGEXP_INSTR'", "'REGEXP_LIKE'", "'REGEXP_MATCH'", "'REGEXP_MATCHES'", + "'REGEXP_REPLACE'", "'REGEXP_SPLIT_TO_ARRAY'", "'REGEXP_SPLIT_TO_TABLE'", + "'REGEXP_SUBSTR'", "'REPEAT'", "'RPAD'", "'RTRIM'", "'SPLIT_PART'", "'STARTS_WITH'", + "'STRING_TO_ARRAY'", "'STRING_TO_TABLE'", "'STRPOS'", "'SUBSTR'", "'TO_ASCII'", + "'TO_HEX'", "'TRANSLATE'", "'UNISTR'", "'AGE'", "'CLOCK_TIMESTAMP'", + "'DATE_BIN'", "'DATE_PART'", "'DATE_TRUNC'", "'ISFINITE'", "'JUSTIFY_DAYS'", + "'JUSTIFY_HOURS'", "'JUSTIFY_INTERVAL'", "'MAKE_DATE'", "'MAKE_INTERVAL'", + "'MAKE_TIME'", "'MAKE_TIMESTAMP'", "'MAKE_TIMESTAMPTZ'", "'NOW'", "'STATEMENT_TIMESTAMP'", + "'TIMEOFDAY'", "'TRANSACTION_TIMESTAMP'", "'TO_TIMESTAMP'", "'TO_CHAR'", + "'TO_DATE'", "'TO_NUMBER'", null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, null, null, null, null, null, null, - null, null, null, null, null, null, "','", "':'", "'::'", "'$'", "'$$'", - "'*'", "'('", "')'", "'['", "']'", null, null, null, null, null, "'.'", - null, null, null, null, null, "'&'", "'&&'", "'&<'", "'@@'", "'@>'", - "'@'", "'!'", "'!!'", "'!='", "'^'", "'='", "'=>'", "'>'", "'>='", "'>>'", - "'#'", "'#='", "'#>'", "'#>>'", "'##'", "'->'", "'->>'", "'-|-'", "'<'", - "'<='", "'<@'", "'<^'", "'<>'", "'<->'", "'<<'", "'<<='", "''", "'-'", - "'%'", "'|'", "'||'", "'||/'", "'|/'", "'+'", "'?'", "'?&'", "'?#'", - "'?-'", "'?|'", "'/'", "'~'", "'~='", "'~>=~'", "'~>~'", "'~<=~'", "'~<~'", - "'~*'", "'~~'", "';'" + null, "'\\\\'", null, null, null, null, null, null, null, "'''" }; } private static final String[] _LITERAL_NAMES = makeLiteralNames(); private static String[] makeSymbolicNames() { return new String[] { - null, "WHITESPACE", "BLOCK_COMMENT", "LINE_COMMENT", "A_", "ABORT", "ABS", - "ABSOLUTE", "ACCESS", "ACTION", "ADA", "ADD", "ADMIN", "AFTER", "AGGREGATE", - "ALIAS", "ALL", "ALLOCATE", "ALSO", "ALTER", "ALWAYS", "ANALYSE", "ANALYZE", - "AND", "ANY", "ARE", "ARRAY", "AS", "ASC", "ASENSITIVE", "ASSERTION", - "ASSIGNMENT", "ASYMMETRIC", "AT", "ATOMIC", "ATTRIBUTE", "ATTRIBUTES", - "AUTHORIZATION", "AVG", "BACKWARD", "BEFORE", "BEGIN", "BERNOULLI", "BETWEEN", - "BIGINT", "BINARY", "BIT", "BIT_LENGTH", "BITVAR", "BLOB", "BOOLEAN", - "BOTH", "BREADTH", "BUFFERS", "BY", "C_", "CACHE", "CALL", "CALLED", - "CARDINALITY", "CASCADE", "CASCADED", "CASE", "CAST", "CATALOG", "CATALOG_NAME", - "CEIL", "CEILING", "CHAIN", "CHAR", "CHAR_LENGTH", "CHARACTER", "CHARACTER_LENGTH", - "CHARACTER_SET_CATALOG", "CHARACTER_SET_NAME", "CHARACTER_SET_SCHEMA", - "CHARACTERISTICS", "CHARACTERS", "CHECK", "CHECKED", "CHECKPOINT", "CLASS", - "CLASS_ORIGIN", "CLOB", "CLOSE", "CLUSTER", "COALESCE", "COBOL", "COLLATE", - "COLLATION", "COLLATION_CATALOG", "COLLATION_NAME", "COLLATION_SCHEMA", - "COLLECT", "COLUMN", "COLUMN_NAME", "COMMAND_FUNCTION", "COMMAND_FUNCTION_CODE", - "COMMENT", "COMMIT", "COMMITTED", "COMPLETION", "CONDITION", "CONDITION_NUMBER", - "CONFIGURATION", "CONFLICT", "CONNECT", "CONNECTION", "CONNECTION_NAME", - "CONSTRAINT", "CONSTRAINT_CATALOG", "CONSTRAINT_NAME", "CONSTRAINT_SCHEMA", - "CONSTRAINTS", "CONSTRUCTOR", "CONTAINS", "CONTINUE", "CONVERSION", "CONVERT", - "COPY", "CORR", "CORRESPONDING", "COSTS", "COUNT", "COVAR_POP", "COVAR_SAMP", - "CREATE", "CREATEDB", "CREATEUSER", "CROSS", "CSV", "CUBE", "CUME_DIST", - "CURRENT", "CURRENT_DATE", "CURRENT_DEFAULT_TRANSFORM_GROUP", "CURRENT_PATH", - "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_TRANSFORM_GROUP_FOR_TYPE", - "CURRENT_USER", "CURSOR", "CURSOR_NAME", "CYCLE", "DATA", "DATABASE", - "DATE", "DATETIME_INTERVAL_CODE", "DATETIME_INTERVAL_PRECISION", "DAY", - "DEALLOCATE", "DEC", "DECIMAL", "DECLARE", "DEFAULT", "DEFAULTS", "DEFERABLE", - "DEFERRABLE", "DEFERRED", "DEFINED", "DEFINER", "DEGREE", "DELETE", "DELIMITER", - "DELIMITERS", "DENSE_RANK", "DEPENDS", "DEPTH", "DEREF", "DERIVED", "DESC", - "DESCRIBE", "DESCRIPTOR", "DESTROY", "DESTRUCTOR", "DETERMINISTIC", "DIAGNOSTICS", - "DICTIONARY", "DISABLE", "DISABLE_PAGE_SKIPPING", "DISCARD", "DISCONNECT", - "DISPATCH", "DISTINCT", "DO", "DOMAIN", "DOUBLE", "DROP", "DYNAMIC", - "DYNAMIC_FUNCTION", "DYNAMIC_FUNCTION_CODE", "EACH", "ELEMENT", "ELSE", - "ENABLE", "ENCODING", "ENCRYPTED", "END", "END_EXEC", "EQUALS", "ESCAPE", - "EVERY", "EXCEPT", "EXCEPTION", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", - "EXEC", "EXECUTE", "EXISTING", "EXISTS", "EXP", "EXPLAIN", "EXTENDED", - "EXTENSION", "EXTERNAL", "EXTRACT", "FALSE", "FETCH", "FIELDS", "FILTER", - "FINAL", "FIRST", "FLOAT", "FLOOR", "FOLLOWING", "FOR", "FORCE", "FOREIGN", - "FORMAT", "FORTRAN", "FORWARD", "FOUND", "FREE", "FREEZE", "FROM", "FULL", - "FUNCTION", "FUSION", "G_", "GENERAL", "GENERATED", "GET", "GLOBAL", - "GO", "GOTO", "GRANT", "GRANTED", "GREATEST", "GROUP", "GROUPING", "HANDLER", - "HAVING", "HIERARCHY", "HOLD", "HOST", "HOUR", "IDENTITY", "IGNORE", - "ILIKE", "IMMEDIATE", "IMMUTABLE", "IMPLEMENTATION", "IMPLICIT", "IN", - "INCLUDING", "INCREMENT", "INDEX", "INDICATOR", "INFIX", "INHERITS", - "INITIALIZE", "INITIALLY", "INNER", "INOUT", "INPUT", "INSENSITIVE", - "INSERT", "INSTANCE", "INSTANTIABLE", "INSTEAD", "INT", "INTEGER", "INTERSECT", - "INTERSECTION", "INTERVAL", "INTO", "INVOKER", "IS", "ISOLATION", "ITERATE", - "JOIN", "K_", "KEY", "KEY_MEMBER", "KEY_TYPE", "LABEL", "LANCOMPILER", - "LANGUAGE", "LARGE", "LAST", "LATERAL", "LEADING", "LEAST", "LEFT", "LENGTH", - "LESS", "LEVEL", "LIKE", "LIMIT", "LISTEN", "LN", "LOAD", "LOCAL", "LOCALTIME", - "LOCALTIMESTAMP", "LOCATION", "LOCATOR", "LOCK", "LOCKED", "LOWER", "M_", - "MAIN", "MAP", "MAPPING", "MATCH", "MATCH_SIMPLE", "MATCHED", "MAX", - "MAXVALUE", "MEMBER", "MERGE", "MESSAGE_LENGTH", "MESSAGE_OCTET_LENGTH", - "MESSAGE_TEXT", "METHOD", "MIN", "MINUTE", "MINVALUE", "MOD", "MODE", - "MODIFIES", "MODIFY", "MODULE", "MONTH", "MORE_", "MOVE", "MULTISET", - "MUMPS", "NAME", "NAMES", "NATIONAL", "NATURAL", "NCHAR", "NCLOB", "NESTING", - "NEW", "NEXT", "NO", "NOCREATEDB", "NOCREATEUSER", "NONE", "NORMALIZE", - "NORMALIZED", "NOT", "NOTHING", "NOTIFY", "NOTNULL", "NOWAIT", "NULL", - "NULLABLE", "NULLIF", "NULLS", "NUMBER", "NUMERIC", "OBJECT", "OCTET_LENGTH", - "OCTETS", "OF", "OFF", "OFFSET", "OIDS", "OLD", "ON", "ONLY", "OPEN", - "OPERATION", "OPERATOR", "OPTION", "OPTIONS", "OR", "ORDER", "ORDERING", - "ORDINALITY", "OTHERS", "OUT", "OUTER", "OUTPUT", "OVER", "OVERLAPS", - "OVERLAY", "OVERRIDING", "OWNER", "PAD", "PARAMETER", "PARAMETER_MODE", - "PARAMETER_NAME", "PARAMETER_ORDINAL_POSITION", "PARAMETER_SPECIFIC_CATALOG", - "PARAMETER_SPECIFIC_NAME", "PARAMETER_SPECIFIC_SCHEMA", "PARAMETERS", - "PARSER", "PARTIAL", "PARTITION", "PASCAL", "PASSWORD", "PATH", "PERCENT_RANK", - "PERCENTILE_CONT", "PERCENTILE_DISC", "PLACING", "PLAIN", "PLANS", "PLI", - "POSITION", "POSTFIX", "POWER", "PRECEDING", "PRECISION", "PREFIX", "PREORDER", - "PREPARE", "PREPARED", "PRESERVE", "PRIMARY", "PRIOR", "PRIVILEGES", - "PROCEDURAL", "PROCEDURE", "PUBLIC", "PUBLICATION", "QUOTE", "RANGE", - "RANK", "READ", "READS", "REAL", "REASSIGN", "RECHECK", "RECURSIVE", - "REF", "REFERENCES", "REFERENCING", "REFRESH", "REGR_AVGX", "REGR_AVGY", - "REGR_COUNT", "REGR_INTERCEPT", "REGR_R2", "REGR_SLOPE", "REGR_SXX", - "REGR_SXY", "REGR_SYY", "REINDEX", "RELATIVE", "RELEASE", "RENAME", "REPEATABLE", - "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", "RESULT", "RETURN", - "RETURNED_CARDINALITY", "RETURNED_LENGTH", "RETURNED_OCTET_LENGTH", "RETURNED_SQLSTATE", - "RETURNING", "RETURNS", "REVOKE", "RIGHT", "ROLE", "ROLLBACK", "ROLLUP", - "ROUTINE", "ROUTINE_CATALOG", "ROUTINE_NAME", "ROUTINE_SCHEMA", "ROW", - "ROW_COUNT", "ROW_NUMBER", "ROWS", "RULE", "SAVEPOINT", "SCALE", "SCHEMA", - "SCHEMA_NAME", "SCOPE", "SCOPE_CATALOG", "SCOPE_NAME", "SCOPE_SCHEMA", - "SCROLL", "SEARCH", "SECOND", "SECTION", "SECURITY", "SELECT", "SELF", - "SENSITIVE", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER_NAME", - "SESSION", "SESSION_USER", "SET", "SETOF", "SETS", "SHARE", "SHOW", "SIMILAR", - "SIMPLE", "SIZE", "SKIP_", "SMALLINT", "SNAPSHOT", "SOME", "SOURCE", - "SPACE", "SPECIFIC", "SPECIFIC_NAME", "SPECIFICTYPE", "SQL", "SQLCODE", - "SQLERROR", "SQLEXCEPTION", "SQLSTATE", "SQLWARNING", "SQRT", "STABLE", - "START", "STATE", "STATEMENT", "STATIC", "STATISTICS", "STDDEV_POP", - "STDDEV_SAMP", "STDIN", "STDOUT", "STORAGE", "STRICT", "STRUCTURE", "STYLE", - "SUBCLASS_ORIGIN", "SUBLIST", "SUBMULTISET", "SUBSCRIPTION", "SUBSTRING", - "SUM", "SYMMETRIC", "SYSID", "SYSTEM", "SYSTEM_USER", "TABLE", "TABLE_NAME", - "TABLESAMPLE", "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TERMINATE", - "THAN", "THEN", "TIES", "TIME", "TIMESTAMP", "TIMEZONE_HOUR", "TIMEZONE_MINUTE", - "TIMING", "TO", "TOAST", "TOP", "TOP_LEVEL_COUNT", "TRAILING", "TRANSACTION", - "TRANSACTION_ACTIVE", "TRANSACTIONS_COMMITTED", "TRANSACTIONS_ROLLED_BACK", - "TRANSFORM", "TRANSFORMS", "TRANSLATE", "TRANSLATION", "TREAT", "TRIGGER", - "TRIGGER_CATALOG", "TRIGGER_NAME", "TRIGGER_SCHEMA", "TRIM", "TRUE", - "TRUNCATE", "TRUSTED", "TYPE", "UESCAPE", "UNBOUNDED", "UNCOMMITTED", - "UNDER", "UNENCRYPTED", "UNION", "UNIQUE", "UNKNOWN", "UNLISTEN", "UNLOGGED", - "UNNAMED", "UNNEST", "UNTIL", "UPDATE", "UPPER", "USAGE", "USER", "USER_DEFINED_TYPE_CATALOG", - "USER_DEFINED_TYPE_CODE", "USER_DEFINED_TYPE_NAME", "USER_DEFINED_TYPE_SCHEMA", - "USING", "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VALUE", "VALUES", - "VAR_POP", "VAR_SAMP", "VARCHAR", "VARIABLE", "VARIADIC", "VARYING", - "VERBOSE", "VIEW", "VOLATILE", "WHEN", "WHENEVER", "WHERE", "WIDTH_BUCKET", - "WINDOW", "WITH", "WITHIN", "WITHOUT", "WORK", "WRITE", "YAML", "YEAR", - "YES", "ZONE", "SUPERUSER", "NOSUPERUSER", "CREATEROLE", "NOCREATEROLE", - "INHERIT", "NOINHERIT", "LOGIN", "NOLOGIN", "REPLICATION", "NOREPLICATION", - "BYPASSRLS", "NOBYPASSRLS", "SFUNC", "STYPE", "SSPACE", "FINALFUNC", - "FINALFUNC_EXTRA", "COMBINEFUNC", "SERIALFUNC", "DESERIALFUNC", "INITCOND", - "MSFUNC", "MINVFUNC", "MSTYPE", "MSSPACE", "MFINALFUNC", "MFINALFUNC_EXTRA", - "MINITCOND", "SORTOP", "PARALLEL", "HYPOTHETICAL", "SAFE", "RESTRICTED", - "UNSAFE", "BASETYPE", "IF", "LOCALE", "LC_COLLATE", "LC_CTYPE", "PROVIDER", - "VERSION", "ALLOW_CONNECTIONS", "IS_TEMPLATE", "EVENT", "WRAPPER", "SERVER", - "BTREE", "HASH_", "GIST", "SPGIST", "GIN", "BRIN", "CONCURRENTLY", "INLINE", - "MATERIALIZED", "LEFTARG", "RIGHTARG", "COMMUTATOR", "NEGATOR", "HASHES", - "MERGES", "FAMILY", "POLICY", "OWNED", "ABSTIME", "BIGSERIAL", "BIT_VARYING", - "BOOL", "BOX", "BYTEA", "CHARACTER_VARYING", "CIDR", "CIRCLE", "FLOAT4", - "FLOAT8", "INET", "INT2", "INT4", "INT8", "JSON", "JSONB", "LINE", "LSEG", - "MACADDR", "MACADDR8", "MONEY", "PG_LSN", "POINT", "POLYGON", "RELTIME", - "SERIAL", "SERIAL2", "SERIAL4", "SERIAL8", "SMALLSERIAL", "STSTEM", "TEXT", - "TIMESTAMPTZ", "TIMETZ", "TSQUERY", "TSVECTOR", "TXID_SNAPSHOT", "UUID", - "VARBIT", "XML", "COMMA", "COLON", "COLON_COLON", "DOLLAR", "DOLLAR_DOLLAR", - "STAR", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET", - "BIT_STRING", "REGEX_STRING", "NUMERIC_LITERAL", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", - "DOT", "SINGLEQ_STRING_LITERAL", "DOUBLEQ_STRING_LITERAL", "IDENTIFIER", - "DOLLAR_DEC", "IDENTIFIER_UNICODE", "AMP", "AMP_AMP", "AMP_LT", "AT_AT", - "AT_GT", "AT_SIGN", "BANG", "BANG_BANG", "BANG_EQUAL", "CARET", "EQUAL", - "EQUAL_GT", "GT", "GTE", "GT_GT", "HASH", "HASH_EQ", "HASH_GT", "HASH_GT_GT", - "HASH_HASH", "HYPHEN_GT", "HYPHEN_GT_GT", "HYPHEN_PIPE_HYPHEN", "LT", - "LTE", "LT_AT", "LT_CARET", "LT_GT", "LT_HYPHEN_GT", "LT_LT", "LT_LT_EQ", - "LT_QMARK_GT", "MINUS", "PERCENT", "PIPE", "PIPE_PIPE", "PIPE_PIPE_SLASH", - "PIPE_SLASH", "PLUS", "QMARK", "QMARK_AMP", "QMARK_HASH", "QMARK_HYPHEN", - "QMARK_PIPE", "SLASH", "TIL", "TIL_EQ", "TIL_GTE_TIL", "TIL_GT_TIL", - "TIL_LTE_TIL", "TIL_LT_TIL", "TIL_STAR", "TIL_TIL", "SEMI", "SPEL" + null, "SPEL", "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", + "CLOSE_BRACKET", "COMMA", "SEMI", "COLON", "QUESTION", "STAR", "EQUAL", + "DOT", "PLUS", "MINUS", "SLASH", "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", + "COLON_EQUALS", "LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", "DOT_DOT", + "NOT_EQUALS", "TYPECAST", "PERCENT", "PARAM", "Operator", "ALL", "ANALYSE", + "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", + "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", + "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", + "CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE", + "EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP_P", + "HAVING", "IN_P", "INITIALLY", "INTERSECT", "INTO", "LATERAL_P", "LEADING", + "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL_P", "OFFSET", "ON", + "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", "REFERENCES", "RETURNING", + "SELECT", "SESSION_USER", "SOME", "SYMMETRIC", "TABLE", "THEN", "TO", + "TRAILING", "TRUE_P", "UNION", "UNIQUE", "USER", "USING", "VARIADIC", + "WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", "BINARY", "COLLATION", + "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", "FREEZE", "FULL", "ILIKE", + "INNER_P", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL", "NOTNULL", + "OUTER_P", "OVER", "OVERLAPS", "RIGHT", "SIMILAR", "VERBOSE", "ABORT_P", + "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", "AFTER", "AGGREGATE", + "ALSO", "ALTER", "ALWAYS", "ASSERTION", "ASSIGNMENT", "AT", "ATTRIBUTE", + "BACKWARD", "BEFORE", "BEGIN_P", "BY", "CACHE", "CALLED", "CASCADE", + "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", "CLASS", + "CLOSE", "CLUSTER", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", "CONFIGURATION", + "CONNECTION", "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", "CONVERSION_P", + "COPY", "COST", "CSV", "CURSOR", "CYCLE", "DATA_P", "DATABASE", "DAY_P", + "DEALLOCATE", "DECLARE", "DEFAULTS", "DEFERRED", "DEFINER", "DELETE_P", + "DELIMITER", "DELIMITERS", "DICTIONARY", "DISABLE_P", "DISCARD", "DOCUMENT_P", + "DOMAIN_P", "DOUBLE_P", "DROP", "EACH", "ENABLE_P", "ENCODING", "ENCRYPTED", + "ENUM_P", "ESCAPE", "EVENT", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", + "EXPLAIN", "EXTENSION", "EXTERNAL", "FAMILY", "FIRST_P", "FOLLOWING", + "FORCE", "FORWARD", "FUNCTION", "FUNCTIONS", "GLOBAL", "GRANTED", "HANDLER", + "HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE", + "IMPLICIT_P", "INCLUDING", "INCREMENT", "INDEX", "INDEXES", "INHERIT", + "INHERITS", "INLINE_P", "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", + "ISOLATION", "KEY", "LABEL", "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF", + "LEVEL", "LISTEN", "LOAD", "LOCAL", "LOCATION", "LOCK_P", "MAPPING", + "MATCH", "MATCHED", "MATERIALIZED", "MAXVALUE", "MERGE", "MINUTE_P", + "MINVALUE", "MODE", "MONTH_P", "MOVE", "NAME_P", "NAMES", "NEXT", "NO", + "NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", "OBJECT_P", "OF", "OFF", "OIDS", + "OPERATOR", "OPTION", "OPTIONS", "OWNED", "OWNER", "PARSER", "PARTIAL", + "PARTITION", "PASSING", "PASSWORD", "PLANS", "PRECEDING", "PREPARE", + "PREPARED", "PRESERVE", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", + "PROGRAM", "QUOTE", "RANGE", "READ", "REASSIGN", "RECHECK", "RECURSIVE", + "REF", "REFRESH", "REINDEX", "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE", + "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE", + "ROLE", "ROLLBACK", "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", + "SEARCH", "SECOND_P", "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", + "SERVER", "SESSION", "SET", "SHARE", "SHOW", "SIMPLE", "SNAPSHOT", "STABLE", + "STANDALONE_P", "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT", + "STORAGE", "STRICT_P", "STRIP_P", "SYSID", "SYSTEM_P", "TABLES", "TABLESPACE", + "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P", "TRANSACTION", "TRIGGER", + "TRUNCATE", "TRUSTED", "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED", + "UNENCRYPTED", "UNKNOWN", "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE", + "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VARYING", "VERSION_P", "VIEW", + "VOLATILE", "WHITESPACE_P", "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML_P", + "YEAR_P", "YES_P", "ZONE", "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P", "CHAR_P", + "CHARACTER", "COALESCE", "DEC", "DECIMAL_P", "EXISTS", "EXTRACT", "FLOAT_P", + "GREATEST", "INOUT", "INT_P", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", + "NCHAR", "NONE", "NULLIF", "NUMERIC", "OVERLAY", "POSITION", "PRECISION", + "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", "TIME", "TIMESTAMP", + "TREAT", "TRIM", "VALUES", "VARCHAR", "XMLATTRIBUTES", "XMLCOMMENT", + "XMLAGG", "XML_IS_WELL_FORMED", "XML_IS_WELL_FORMED_DOCUMENT", "XML_IS_WELL_FORMED_CONTENT", + "XPATH", "XPATH_EXISTS", "XMLCONCAT", "XMLELEMENT", "XMLEXISTS", "XMLFOREST", + "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE", "CALL", "CURRENT_P", + "ATTACH", "DETACH", "EXPRESSION", "GENERATED", "LOGGED", "STORED", "INCLUDE", + "ROUTINE", "TRANSFORM", "IMPORT_P", "POLICY", "METHOD", "REFERENCING", + "NEW", "OLD", "VALUE_P", "SUBSCRIPTION", "PUBLICATION", "OUT_P", "END_P", + "ROUTINES", "SCHEMAS", "PROCEDURES", "INPUT_P", "SUPPORT", "PARALLEL", + "SQL_P", "DEPENDS", "OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", + "ROLLUP", "CUBE", "GROUPING", "SETS", "TABLESAMPLE", "ORDINALITY", "XMLTABLE", + "COLUMNS", "XMLNAMESPACES", "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", + "GROUPS", "OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", "VIEWS", + "NORMALIZE", "DUMP", "PRINT_STRICT_PARAMS", "VARIABLE_CONFLICT", "ERROR", + "USE_VARIABLE", "USE_COLUMN", "ALIAS", "CONSTANT", "PERFORM", "GET", + "DIAGNOSTICS", "STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", "SLICE", + "EXIT", "RETURN", "QUERY", "RAISE", "SQLSTATE", "DEBUG", "LOG", "INFO", + "NOTICE", "WARNING", "EXCEPTION", "ASSERT", "LOOP", "OPEN", "TOP", "ABS", + "CBRT", "CEIL", "CEILING", "DEGREES", "DIV", "EXP", "FACTORIAL", "FLOOR", + "GCD", "LCM", "LN", "LOG10", "MIN_SCALE", "MOD", "PI", "POWER", "RADIANS", + "ROUND", "SCALE", "SIGN", "SQRT", "TRIM_SCALE", "TRUNC", "WIDTH_BUCKET", + "RANDOM", "SETSEED", "ACOS", "ACOSD", "ASIN", "ASIND", "ATAN", "ATAND", + "ATAN2", "ATAN2D", "COS", "COSD", "COT", "COTD", "SIN", "SIND", "TAN", + "TAND", "SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "BIT_LENGTH", + "CHAR_LENGTH", "CHARACTER_LENGTH", "LOWER", "OCTET_LENGTH", "UPPER", + "ASCII", "BTRIM", "CHR", "CONCAT", "CONCAT_WS", "FORMAT", "INITCAP", + "LENGTH", "LPAD", "LTRIM", "MD5", "PARSE_IDENT", "PG_CLIENT_ENCODING", + "QUOTE_IDENT", "QUOTE_LITERAL", "QUOTE_NULLABLE", "REGEXP_COUNT", "REGEXP_INSTR", + "REGEXP_LIKE", "REGEXP_MATCH", "REGEXP_MATCHES", "REGEXP_REPLACE", "REGEXP_SPLIT_TO_ARRAY", + "REGEXP_SPLIT_TO_TABLE", "REGEXP_SUBSTR", "REPEAT", "RPAD", "RTRIM", + "SPLIT_PART", "STARTS_WITH", "STRING_TO_ARRAY", "STRING_TO_TABLE", "STRPOS", + "SUBSTR", "TO_ASCII", "TO_HEX", "TRANSLATE", "UNISTR", "AGE", "CLOCK_TIMESTAMP", + "DATE_BIN", "DATE_PART", "DATE_TRUNC", "ISFINITE", "JUSTIFY_DAYS", "JUSTIFY_HOURS", + "JUSTIFY_INTERVAL", "MAKE_DATE", "MAKE_INTERVAL", "MAKE_TIME", "MAKE_TIMESTAMP", + "MAKE_TIMESTAMPTZ", "NOW", "STATEMENT_TIMESTAMP", "TIMEOFDAY", "TRANSACTION_TIMESTAMP", + "TO_TIMESTAMP", "TO_CHAR", "TO_DATE", "TO_NUMBER", "Identifier", "QuotedIdentifier", + "UnterminatedQuotedIdentifier", "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier", + "UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", "InvalidUnicodeQuotedIdentifier", + "InvalidUnterminatedUnicodeQuotedIdentifier", "StringConstant", "UnterminatedStringConstant", + "UnicodeEscapeStringConstant", "UnterminatedUnicodeEscapeStringConstant", + "BeginDollarStringConstant", "BinaryStringConstant", "UnterminatedBinaryStringConstant", + "InvalidBinaryStringConstant", "InvalidUnterminatedBinaryStringConstant", + "HexadecimalStringConstant", "UnterminatedHexadecimalStringConstant", + "InvalidHexadecimalStringConstant", "InvalidUnterminatedHexadecimalStringConstant", + "Integral", "NumericFail", "Numeric", "PLSQLIDENTIFIER", "Whitespace", + "Newline", "LineComment", "BlockComment", "UnterminatedBlockComment", + "MetaCommand", "EndMetaCommand", "ErrorCharacter", "EscapeStringConstant", + "UnterminatedEscapeStringConstant", "InvalidEscapeStringConstant", "InvalidUnterminatedEscapeStringConstant", + "DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued" }; } private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); @@ -598,6 +884,8 @@ public class PostgreSqlParser extends Parser { @Override public ATN getATN() { return _ATN; } + + public PostgreSqlParser(TokenStream input) { super(input); _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); @@ -605,17 +893,10 @@ public class PostgreSqlParser extends Parser { @SuppressWarnings("CheckReturnValue") public static class RootContext extends ParserRuleContext { - public List stmt() { - return getRuleContexts(StmtContext.class); - } - public StmtContext stmt(int i) { - return getRuleContext(StmtContext.class,i); + public StmtblockContext stmtblock() { + return getRuleContext(StmtblockContext.class,0); } public TerminalNode EOF() { return getToken(PostgreSqlParser.EOF, 0); } - public List SEMI() { return getTokens(PostgreSqlParser.SEMI); } - public TerminalNode SEMI(int i) { - return getToken(PostgreSqlParser.SEMI, i); - } public RootContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -633,42 +914,12 @@ public class PostgreSqlParser extends Parser { public final RootContext root() throws RecognitionException { RootContext _localctx = new RootContext(_ctx, getState()); enterRule(_localctx, 0, RULE_root); - int _la; try { - int _alt; enterOuterAlt(_localctx, 1); { - setState(546); - stmt(); - setState(555); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMI) { - { - setState(551); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,0,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(547); - match(SEMI); - setState(548); - stmt(); - } - } - } - setState(553); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,0,_ctx); - } - setState(554); - match(SEMI); - } - } - - setState(557); + setState(1626); + stmtblock(); + setState(1627); match(EOF); } } @@ -683,163 +934,532 @@ public class PostgreSqlParser extends Parser { return _localctx; } + @SuppressWarnings("CheckReturnValue") + public static class PlsqlrootContext extends ParserRuleContext { + public Pl_functionContext pl_function() { + return getRuleContext(Pl_functionContext.class,0); + } + public PlsqlrootContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_plsqlroot; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPlsqlroot(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPlsqlroot(this); + } + } + + public final PlsqlrootContext plsqlroot() throws RecognitionException { + PlsqlrootContext _localctx = new PlsqlrootContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_plsqlroot); + try { + enterOuterAlt(_localctx, 1); + { + setState(1629); + pl_function(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StmtblockContext extends ParserRuleContext { + public StmtmultiContext stmtmulti() { + return getRuleContext(StmtmultiContext.class,0); + } + public StmtblockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmtblock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmtblock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmtblock(this); + } + } + + public final StmtblockContext stmtblock() throws RecognitionException { + StmtblockContext _localctx = new StmtblockContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_stmtblock); + try { + enterOuterAlt(_localctx, 1); + { + setState(1631); + stmtmulti(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StmtmultiContext extends ParserRuleContext { + public List stmt() { + return getRuleContexts(StmtContext.class); + } + public StmtContext stmt(int i) { + return getRuleContext(StmtContext.class,i); + } + public List SEMI() { return getTokens(PostgreSqlParser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(PostgreSqlParser.SEMI, i); + } + public StmtmultiContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmtmulti; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmtmulti(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmtmulti(this); + } + } + + public final StmtmultiContext stmtmulti() throws RecognitionException { + StmtmultiContext _localctx = new StmtmultiContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_stmtmulti); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1639); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8646629783804837880L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 1099654234113L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 4909769124516856321L) != 0) || ((((_la - 204)) & ~0x3f) == 0 && ((1L << (_la - 204)) & 4686037194794598403L) != 0) || ((((_la - 285)) & ~0x3f) == 0 && ((1L << (_la - 285)) & 1170022785714177L) != 0) || ((((_la - 353)) & ~0x3f) == 0 && ((1L << (_la - 353)) & 6401L) != 0) || ((((_la - 417)) & ~0x3f) == 0 && ((1L << (_la - 417)) & 550292946945L) != 0) || _la==MetaCommand) { + { + { + setState(1633); + stmt(); + setState(1635); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(1634); + match(SEMI); + } + } + + } + } + setState(1641); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + @SuppressWarnings("CheckReturnValue") public static class StmtContext extends ParserRuleContext { - public Abort_stmtContext abort_stmt() { - return getRuleContext(Abort_stmtContext.class,0); + public AltereventtrigstmtContext altereventtrigstmt() { + return getRuleContext(AltereventtrigstmtContext.class,0); } - public Alter_stmtContext alter_stmt() { - return getRuleContext(Alter_stmtContext.class,0); + public AltercollationstmtContext altercollationstmt() { + return getRuleContext(AltercollationstmtContext.class,0); } - public Analyze_stmtContext analyze_stmt() { - return getRuleContext(Analyze_stmtContext.class,0); + public AlterdatabasestmtContext alterdatabasestmt() { + return getRuleContext(AlterdatabasestmtContext.class,0); } - public Create_stmtContext create_stmt() { - return getRuleContext(Create_stmtContext.class,0); + public AlterdatabasesetstmtContext alterdatabasesetstmt() { + return getRuleContext(AlterdatabasesetstmtContext.class,0); } - public Close_stmtContext close_stmt() { - return getRuleContext(Close_stmtContext.class,0); + public AlterdefaultprivilegesstmtContext alterdefaultprivilegesstmt() { + return getRuleContext(AlterdefaultprivilegesstmtContext.class,0); } - public Cluster_stmtContext cluster_stmt() { - return getRuleContext(Cluster_stmtContext.class,0); + public AlterdomainstmtContext alterdomainstmt() { + return getRuleContext(AlterdomainstmtContext.class,0); } - public Comment_stmtContext comment_stmt() { - return getRuleContext(Comment_stmtContext.class,0); + public AlterenumstmtContext alterenumstmt() { + return getRuleContext(AlterenumstmtContext.class,0); } - public Commit_stmtContext commit_stmt() { - return getRuleContext(Commit_stmtContext.class,0); + public AlterextensionstmtContext alterextensionstmt() { + return getRuleContext(AlterextensionstmtContext.class,0); } - public Commit_prepared_stmtContext commit_prepared_stmt() { - return getRuleContext(Commit_prepared_stmtContext.class,0); + public AlterextensioncontentsstmtContext alterextensioncontentsstmt() { + return getRuleContext(AlterextensioncontentsstmtContext.class,0); } - public Copy_stmtContext copy_stmt() { - return getRuleContext(Copy_stmtContext.class,0); + public AlterfdwstmtContext alterfdwstmt() { + return getRuleContext(AlterfdwstmtContext.class,0); } - public Deallocate_stmtContext deallocate_stmt() { - return getRuleContext(Deallocate_stmtContext.class,0); + public AlterforeignserverstmtContext alterforeignserverstmt() { + return getRuleContext(AlterforeignserverstmtContext.class,0); } - public Declare_stmtContext declare_stmt() { - return getRuleContext(Declare_stmtContext.class,0); + public AlterfunctionstmtContext alterfunctionstmt() { + return getRuleContext(AlterfunctionstmtContext.class,0); } - public Delete_stmtContext delete_stmt() { - return getRuleContext(Delete_stmtContext.class,0); + public AltergroupstmtContext altergroupstmt() { + return getRuleContext(AltergroupstmtContext.class,0); } - public Discard_stmtContext discard_stmt() { - return getRuleContext(Discard_stmtContext.class,0); + public AlterobjectdependsstmtContext alterobjectdependsstmt() { + return getRuleContext(AlterobjectdependsstmtContext.class,0); } - public Drop_stmtContext drop_stmt() { - return getRuleContext(Drop_stmtContext.class,0); + public AlterobjectschemastmtContext alterobjectschemastmt() { + return getRuleContext(AlterobjectschemastmtContext.class,0); } - public Execute_stmtContext execute_stmt() { - return getRuleContext(Execute_stmtContext.class,0); + public AlterownerstmtContext alterownerstmt() { + return getRuleContext(AlterownerstmtContext.class,0); } - public Explain_stmtContext explain_stmt() { - return getRuleContext(Explain_stmtContext.class,0); + public AlteroperatorstmtContext alteroperatorstmt() { + return getRuleContext(AlteroperatorstmtContext.class,0); } - public Fetch_stmtContext fetch_stmt() { - return getRuleContext(Fetch_stmtContext.class,0); + public AltertypestmtContext altertypestmt() { + return getRuleContext(AltertypestmtContext.class,0); } - public Grant_stmtContext grant_stmt() { - return getRuleContext(Grant_stmtContext.class,0); + public AlterpolicystmtContext alterpolicystmt() { + return getRuleContext(AlterpolicystmtContext.class,0); } - public Import_foreign_schema_stmtContext import_foreign_schema_stmt() { - return getRuleContext(Import_foreign_schema_stmtContext.class,0); + public AlterseqstmtContext alterseqstmt() { + return getRuleContext(AlterseqstmtContext.class,0); } - public Insert_stmtContext insert_stmt() { - return getRuleContext(Insert_stmtContext.class,0); + public AltersystemstmtContext altersystemstmt() { + return getRuleContext(AltersystemstmtContext.class,0); } - public Listen_stmtContext listen_stmt() { - return getRuleContext(Listen_stmtContext.class,0); + public AltertablestmtContext altertablestmt() { + return getRuleContext(AltertablestmtContext.class,0); } - public Load_stmtContext load_stmt() { - return getRuleContext(Load_stmtContext.class,0); + public AltertblspcstmtContext altertblspcstmt() { + return getRuleContext(AltertblspcstmtContext.class,0); } - public Lock_stmtContext lock_stmt() { - return getRuleContext(Lock_stmtContext.class,0); + public AltercompositetypestmtContext altercompositetypestmt() { + return getRuleContext(AltercompositetypestmtContext.class,0); } - public Move_stmtContext move_stmt() { - return getRuleContext(Move_stmtContext.class,0); + public AlterpublicationstmtContext alterpublicationstmt() { + return getRuleContext(AlterpublicationstmtContext.class,0); } - public Notify_stmtContext notify_stmt() { - return getRuleContext(Notify_stmtContext.class,0); + public AlterrolesetstmtContext alterrolesetstmt() { + return getRuleContext(AlterrolesetstmtContext.class,0); } - public Prepare_stmtContext prepare_stmt() { - return getRuleContext(Prepare_stmtContext.class,0); + public AlterrolestmtContext alterrolestmt() { + return getRuleContext(AlterrolestmtContext.class,0); } - public Prepare_transaction_stmtContext prepare_transaction_stmt() { - return getRuleContext(Prepare_transaction_stmtContext.class,0); + public AltersubscriptionstmtContext altersubscriptionstmt() { + return getRuleContext(AltersubscriptionstmtContext.class,0); } - public Reassign_owned_stmtContext reassign_owned_stmt() { - return getRuleContext(Reassign_owned_stmtContext.class,0); + public AlterstatsstmtContext alterstatsstmt() { + return getRuleContext(AlterstatsstmtContext.class,0); } - public Refresh_materialized_view_stmtContext refresh_materialized_view_stmt() { - return getRuleContext(Refresh_materialized_view_stmtContext.class,0); + public AltertsconfigurationstmtContext altertsconfigurationstmt() { + return getRuleContext(AltertsconfigurationstmtContext.class,0); } - public Reindex_stmtContext reindex_stmt() { - return getRuleContext(Reindex_stmtContext.class,0); + public AltertsdictionarystmtContext altertsdictionarystmt() { + return getRuleContext(AltertsdictionarystmtContext.class,0); } - public Release_savepoint_stmtContext release_savepoint_stmt() { - return getRuleContext(Release_savepoint_stmtContext.class,0); + public AlterusermappingstmtContext alterusermappingstmt() { + return getRuleContext(AlterusermappingstmtContext.class,0); } - public Reset_stmtContext reset_stmt() { - return getRuleContext(Reset_stmtContext.class,0); + public AnalyzestmtContext analyzestmt() { + return getRuleContext(AnalyzestmtContext.class,0); } - public Revoke_stmtContext revoke_stmt() { - return getRuleContext(Revoke_stmtContext.class,0); + public CallstmtContext callstmt() { + return getRuleContext(CallstmtContext.class,0); } - public Rollback_stmtContext rollback_stmt() { - return getRuleContext(Rollback_stmtContext.class,0); + public CheckpointstmtContext checkpointstmt() { + return getRuleContext(CheckpointstmtContext.class,0); } - public Rollback_prepared_stmtContext rollback_prepared_stmt() { - return getRuleContext(Rollback_prepared_stmtContext.class,0); + public CloseportalstmtContext closeportalstmt() { + return getRuleContext(CloseportalstmtContext.class,0); } - public Rollback_to_savepoint_stmtContext rollback_to_savepoint_stmt() { - return getRuleContext(Rollback_to_savepoint_stmtContext.class,0); + public ClusterstmtContext clusterstmt() { + return getRuleContext(ClusterstmtContext.class,0); } - public Savepoint_stmtContext savepoint_stmt() { - return getRuleContext(Savepoint_stmtContext.class,0); + public CommentstmtContext commentstmt() { + return getRuleContext(CommentstmtContext.class,0); } - public Security_label_stmtContext security_label_stmt() { - return getRuleContext(Security_label_stmtContext.class,0); + public ConstraintssetstmtContext constraintssetstmt() { + return getRuleContext(ConstraintssetstmtContext.class,0); } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); + public CopystmtContext copystmt() { + return getRuleContext(CopystmtContext.class,0); } - public Select_into_stmtContext select_into_stmt() { - return getRuleContext(Select_into_stmtContext.class,0); + public CreateamstmtContext createamstmt() { + return getRuleContext(CreateamstmtContext.class,0); } - public Set_stmtContext set_stmt() { - return getRuleContext(Set_stmtContext.class,0); + public CreateasstmtContext createasstmt() { + return getRuleContext(CreateasstmtContext.class,0); } - public Set_constraints_stmtContext set_constraints_stmt() { - return getRuleContext(Set_constraints_stmtContext.class,0); + public CreateassertionstmtContext createassertionstmt() { + return getRuleContext(CreateassertionstmtContext.class,0); } - public Set_role_stmtContext set_role_stmt() { - return getRuleContext(Set_role_stmtContext.class,0); + public CreatecaststmtContext createcaststmt() { + return getRuleContext(CreatecaststmtContext.class,0); } - public Set_session_authorization_stmtContext set_session_authorization_stmt() { - return getRuleContext(Set_session_authorization_stmtContext.class,0); + public CreateconversionstmtContext createconversionstmt() { + return getRuleContext(CreateconversionstmtContext.class,0); } - public Set_transaction_stmtContext set_transaction_stmt() { - return getRuleContext(Set_transaction_stmtContext.class,0); + public CreatedomainstmtContext createdomainstmt() { + return getRuleContext(CreatedomainstmtContext.class,0); } - public Show_stmtContext show_stmt() { - return getRuleContext(Show_stmtContext.class,0); + public CreateextensionstmtContext createextensionstmt() { + return getRuleContext(CreateextensionstmtContext.class,0); } - public Truncate_stmtContext truncate_stmt() { - return getRuleContext(Truncate_stmtContext.class,0); + public CreatefdwstmtContext createfdwstmt() { + return getRuleContext(CreatefdwstmtContext.class,0); } - public Unlisten_stmtContext unlisten_stmt() { - return getRuleContext(Unlisten_stmtContext.class,0); + public CreateforeignserverstmtContext createforeignserverstmt() { + return getRuleContext(CreateforeignserverstmtContext.class,0); } - public Update_stmtContext update_stmt() { - return getRuleContext(Update_stmtContext.class,0); + public CreateforeigntablestmtContext createforeigntablestmt() { + return getRuleContext(CreateforeigntablestmtContext.class,0); } - public Vacuum_stmtContext vacuum_stmt() { - return getRuleContext(Vacuum_stmtContext.class,0); + public CreatefunctionstmtContext createfunctionstmt() { + return getRuleContext(CreatefunctionstmtContext.class,0); } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); + public CreategroupstmtContext creategroupstmt() { + return getRuleContext(CreategroupstmtContext.class,0); + } + public CreatematviewstmtContext creatematviewstmt() { + return getRuleContext(CreatematviewstmtContext.class,0); + } + public CreateopclassstmtContext createopclassstmt() { + return getRuleContext(CreateopclassstmtContext.class,0); + } + public CreateopfamilystmtContext createopfamilystmt() { + return getRuleContext(CreateopfamilystmtContext.class,0); + } + public CreatepublicationstmtContext createpublicationstmt() { + return getRuleContext(CreatepublicationstmtContext.class,0); + } + public AlteropfamilystmtContext alteropfamilystmt() { + return getRuleContext(AlteropfamilystmtContext.class,0); + } + public CreatepolicystmtContext createpolicystmt() { + return getRuleContext(CreatepolicystmtContext.class,0); + } + public CreateplangstmtContext createplangstmt() { + return getRuleContext(CreateplangstmtContext.class,0); + } + public CreateschemastmtContext createschemastmt() { + return getRuleContext(CreateschemastmtContext.class,0); + } + public CreateseqstmtContext createseqstmt() { + return getRuleContext(CreateseqstmtContext.class,0); + } + public CreatestmtContext createstmt() { + return getRuleContext(CreatestmtContext.class,0); + } + public CreatesubscriptionstmtContext createsubscriptionstmt() { + return getRuleContext(CreatesubscriptionstmtContext.class,0); + } + public CreatestatsstmtContext createstatsstmt() { + return getRuleContext(CreatestatsstmtContext.class,0); + } + public CreatetablespacestmtContext createtablespacestmt() { + return getRuleContext(CreatetablespacestmtContext.class,0); + } + public CreatetransformstmtContext createtransformstmt() { + return getRuleContext(CreatetransformstmtContext.class,0); + } + public CreatetrigstmtContext createtrigstmt() { + return getRuleContext(CreatetrigstmtContext.class,0); + } + public CreateeventtrigstmtContext createeventtrigstmt() { + return getRuleContext(CreateeventtrigstmtContext.class,0); + } + public CreaterolestmtContext createrolestmt() { + return getRuleContext(CreaterolestmtContext.class,0); + } + public CreateuserstmtContext createuserstmt() { + return getRuleContext(CreateuserstmtContext.class,0); + } + public CreateusermappingstmtContext createusermappingstmt() { + return getRuleContext(CreateusermappingstmtContext.class,0); + } + public CreatedbstmtContext createdbstmt() { + return getRuleContext(CreatedbstmtContext.class,0); + } + public DeallocatestmtContext deallocatestmt() { + return getRuleContext(DeallocatestmtContext.class,0); + } + public DeclarecursorstmtContext declarecursorstmt() { + return getRuleContext(DeclarecursorstmtContext.class,0); + } + public DefinestmtContext definestmt() { + return getRuleContext(DefinestmtContext.class,0); + } + public DeletestmtContext deletestmt() { + return getRuleContext(DeletestmtContext.class,0); + } + public DiscardstmtContext discardstmt() { + return getRuleContext(DiscardstmtContext.class,0); + } + public DostmtContext dostmt() { + return getRuleContext(DostmtContext.class,0); + } + public DropcaststmtContext dropcaststmt() { + return getRuleContext(DropcaststmtContext.class,0); + } + public DropopclassstmtContext dropopclassstmt() { + return getRuleContext(DropopclassstmtContext.class,0); + } + public DropopfamilystmtContext dropopfamilystmt() { + return getRuleContext(DropopfamilystmtContext.class,0); + } + public DropownedstmtContext dropownedstmt() { + return getRuleContext(DropownedstmtContext.class,0); + } + public DropstmtContext dropstmt() { + return getRuleContext(DropstmtContext.class,0); + } + public DropsubscriptionstmtContext dropsubscriptionstmt() { + return getRuleContext(DropsubscriptionstmtContext.class,0); + } + public DroptablespacestmtContext droptablespacestmt() { + return getRuleContext(DroptablespacestmtContext.class,0); + } + public DroptransformstmtContext droptransformstmt() { + return getRuleContext(DroptransformstmtContext.class,0); + } + public DroprolestmtContext droprolestmt() { + return getRuleContext(DroprolestmtContext.class,0); + } + public DropusermappingstmtContext dropusermappingstmt() { + return getRuleContext(DropusermappingstmtContext.class,0); + } + public DropdbstmtContext dropdbstmt() { + return getRuleContext(DropdbstmtContext.class,0); + } + public ExecutestmtContext executestmt() { + return getRuleContext(ExecutestmtContext.class,0); + } + public ExplainstmtContext explainstmt() { + return getRuleContext(ExplainstmtContext.class,0); + } + public FetchstmtContext fetchstmt() { + return getRuleContext(FetchstmtContext.class,0); + } + public GrantstmtContext grantstmt() { + return getRuleContext(GrantstmtContext.class,0); + } + public GrantrolestmtContext grantrolestmt() { + return getRuleContext(GrantrolestmtContext.class,0); + } + public ImportforeignschemastmtContext importforeignschemastmt() { + return getRuleContext(ImportforeignschemastmtContext.class,0); + } + public IndexstmtContext indexstmt() { + return getRuleContext(IndexstmtContext.class,0); + } + public InsertstmtContext insertstmt() { + return getRuleContext(InsertstmtContext.class,0); + } + public MergestmtContext mergestmt() { + return getRuleContext(MergestmtContext.class,0); + } + public ListenstmtContext listenstmt() { + return getRuleContext(ListenstmtContext.class,0); + } + public RefreshmatviewstmtContext refreshmatviewstmt() { + return getRuleContext(RefreshmatviewstmtContext.class,0); + } + public LoadstmtContext loadstmt() { + return getRuleContext(LoadstmtContext.class,0); + } + public LockstmtContext lockstmt() { + return getRuleContext(LockstmtContext.class,0); + } + public NotifystmtContext notifystmt() { + return getRuleContext(NotifystmtContext.class,0); + } + public PreparestmtContext preparestmt() { + return getRuleContext(PreparestmtContext.class,0); + } + public ReassignownedstmtContext reassignownedstmt() { + return getRuleContext(ReassignownedstmtContext.class,0); + } + public ReindexstmtContext reindexstmt() { + return getRuleContext(ReindexstmtContext.class,0); + } + public RemoveaggrstmtContext removeaggrstmt() { + return getRuleContext(RemoveaggrstmtContext.class,0); + } + public RemovefuncstmtContext removefuncstmt() { + return getRuleContext(RemovefuncstmtContext.class,0); + } + public RemoveoperstmtContext removeoperstmt() { + return getRuleContext(RemoveoperstmtContext.class,0); + } + public RenamestmtContext renamestmt() { + return getRuleContext(RenamestmtContext.class,0); + } + public RevokestmtContext revokestmt() { + return getRuleContext(RevokestmtContext.class,0); + } + public RevokerolestmtContext revokerolestmt() { + return getRuleContext(RevokerolestmtContext.class,0); + } + public RulestmtContext rulestmt() { + return getRuleContext(RulestmtContext.class,0); + } + public SeclabelstmtContext seclabelstmt() { + return getRuleContext(SeclabelstmtContext.class,0); + } + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public TransactionstmtContext transactionstmt() { + return getRuleContext(TransactionstmtContext.class,0); + } + public TruncatestmtContext truncatestmt() { + return getRuleContext(TruncatestmtContext.class,0); + } + public UnlistenstmtContext unlistenstmt() { + return getRuleContext(UnlistenstmtContext.class,0); + } + public UpdatestmtContext updatestmt() { + return getRuleContext(UpdatestmtContext.class,0); + } + public VacuumstmtContext vacuumstmt() { + return getRuleContext(VacuumstmtContext.class,0); + } + public VariableresetstmtContext variableresetstmt() { + return getRuleContext(VariableresetstmtContext.class,0); + } + public VariablesetstmtContext variablesetstmt() { + return getRuleContext(VariablesetstmtContext.class,0); + } + public VariableshowstmtContext variableshowstmt() { + return getRuleContext(VariableshowstmtContext.class,0); + } + public ViewstmtContext viewstmt() { + return getRuleContext(ViewstmtContext.class,0); + } + public PlsqlconsolecommandContext plsqlconsolecommand() { + return getRuleContext(PlsqlconsolecommandContext.class,0); } public StmtContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -857,20623 +1477,884 @@ public class PostgreSqlParser extends Parser { public final StmtContext stmt() throws RecognitionException { StmtContext _localctx = new StmtContext(_ctx, getState()); - enterRule(_localctx, 2, RULE_stmt); + enterRule(_localctx, 8, RULE_stmt); try { - enterOuterAlt(_localctx, 1); - { - setState(611); + setState(1767); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) { - case 1: - { - setState(559); - abort_stmt(); - } - break; - case 2: - { - setState(560); - alter_stmt(); - } - break; - case 3: - { - setState(561); - analyze_stmt(); - } - break; - case 4: - { - setState(562); - create_stmt(); - } - break; - case 5: - { - setState(563); - close_stmt(); - } - break; - case 6: - { - setState(564); - cluster_stmt(); - } - break; - case 7: - { - setState(565); - comment_stmt(); - } - break; - case 8: - { - setState(566); - commit_stmt(); - } - break; - case 9: - { - setState(567); - commit_prepared_stmt(); - } - break; - case 10: - { - setState(568); - copy_stmt(); - } - break; - case 11: - { - setState(569); - deallocate_stmt(); - } - break; - case 12: - { - setState(570); - declare_stmt(); - } - break; - case 13: - { - setState(571); - delete_stmt(); - } - break; - case 14: - { - setState(572); - discard_stmt(); - } - break; - case 15: - { - setState(573); - drop_stmt(); - } - break; - case 16: - { - setState(574); - execute_stmt(); - } - break; - case 17: - { - setState(575); - explain_stmt(); - } - break; - case 18: - { - setState(576); - fetch_stmt(); - } - break; - case 19: - { - setState(577); - grant_stmt(); - } - break; - case 20: - { - setState(578); - import_foreign_schema_stmt(); - } - break; - case 21: - { - setState(579); - insert_stmt(); - } - break; - case 22: - { - setState(580); - listen_stmt(); - } - break; - case 23: - { - setState(581); - load_stmt(); - } - break; - case 24: - { - setState(582); - lock_stmt(); - } - break; - case 25: - { - setState(583); - move_stmt(); - } - break; - case 26: - { - setState(584); - notify_stmt(); - } - break; - case 27: - { - setState(585); - prepare_stmt(); - } - break; - case 28: - { - setState(586); - prepare_transaction_stmt(); - } - break; - case 29: - { - setState(587); - reassign_owned_stmt(); - } - break; - case 30: - { - setState(588); - refresh_materialized_view_stmt(); - } - break; - case 31: - { - setState(589); - reindex_stmt(); - } - break; - case 32: - { - setState(590); - release_savepoint_stmt(); - } - break; - case 33: - { - setState(591); - reset_stmt(); - } - break; - case 34: - { - setState(592); - revoke_stmt(); - } - break; - case 35: - { - setState(593); - rollback_stmt(); - } - break; - case 36: - { - setState(594); - rollback_prepared_stmt(); - } - break; - case 37: - { - setState(595); - rollback_to_savepoint_stmt(); - } - break; - case 38: - { - setState(596); - savepoint_stmt(); - } - break; - case 39: - { - setState(597); - security_label_stmt(); - } - break; - case 40: - { - setState(598); - select_stmt(); - } - break; - case 41: - { - setState(599); - select_into_stmt(); - } - break; - case 42: - { - setState(600); - set_stmt(); - } - break; - case 43: - { - setState(601); - set_constraints_stmt(); - } - break; - case 44: - { - setState(602); - set_role_stmt(); - } - break; - case 45: - { - setState(603); - set_session_authorization_stmt(); - } - break; - case 46: - { - setState(604); - set_transaction_stmt(); - } - break; - case 47: - { - setState(605); - show_stmt(); - } - break; - case 48: - { - setState(606); - truncate_stmt(); - } - break; - case 49: - { - setState(607); - unlisten_stmt(); - } - break; - case 50: - { - setState(608); - update_stmt(); - } - break; - case 51: - { - setState(609); - vacuum_stmt(); - } - break; - case 52: - { - setState(610); - values_stmt(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Abort_stmtContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Abort_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_abort_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAbort_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAbort_stmt(this); - } - } - - public final Abort_stmtContext abort_stmt() throws RecognitionException { - Abort_stmtContext _localctx = new Abort_stmtContext(_ctx, getState()); - enterRule(_localctx, 4, RULE_abort_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(613); - identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_stmtContext extends ParserRuleContext { - public Alter_aggregate_stmtContext alter_aggregate_stmt() { - return getRuleContext(Alter_aggregate_stmtContext.class,0); - } - public Alter_collation_stmtContext alter_collation_stmt() { - return getRuleContext(Alter_collation_stmtContext.class,0); - } - public Alter_conversion_stmtContext alter_conversion_stmt() { - return getRuleContext(Alter_conversion_stmtContext.class,0); - } - public Alter_database_stmtContext alter_database_stmt() { - return getRuleContext(Alter_database_stmtContext.class,0); - } - public Alter_default_privileges_stmtContext alter_default_privileges_stmt() { - return getRuleContext(Alter_default_privileges_stmtContext.class,0); - } - public Alter_domain_stmtContext alter_domain_stmt() { - return getRuleContext(Alter_domain_stmtContext.class,0); - } - public Alter_event_trigger_stmtContext alter_event_trigger_stmt() { - return getRuleContext(Alter_event_trigger_stmtContext.class,0); - } - public Alter_extension_stmtContext alter_extension_stmt() { - return getRuleContext(Alter_extension_stmtContext.class,0); - } - public Alter_foreign_data_wrapper_stmtContext alter_foreign_data_wrapper_stmt() { - return getRuleContext(Alter_foreign_data_wrapper_stmtContext.class,0); - } - public Alter_foreign_table_stmtContext alter_foreign_table_stmt() { - return getRuleContext(Alter_foreign_table_stmtContext.class,0); - } - public Alter_function_stmtContext alter_function_stmt() { - return getRuleContext(Alter_function_stmtContext.class,0); - } - public Alter_group_stmtContext alter_group_stmt() { - return getRuleContext(Alter_group_stmtContext.class,0); - } - public Alter_index_stmtContext alter_index_stmt() { - return getRuleContext(Alter_index_stmtContext.class,0); - } - public Alter_language_stmtContext alter_language_stmt() { - return getRuleContext(Alter_language_stmtContext.class,0); - } - public Alter_large_object_stmtContext alter_large_object_stmt() { - return getRuleContext(Alter_large_object_stmtContext.class,0); - } - public Alter_materialize_view_stmtContext alter_materialize_view_stmt() { - return getRuleContext(Alter_materialize_view_stmtContext.class,0); - } - public Alter_operator_stmtContext alter_operator_stmt() { - return getRuleContext(Alter_operator_stmtContext.class,0); - } - public Alter_operator_class_stmtContext alter_operator_class_stmt() { - return getRuleContext(Alter_operator_class_stmtContext.class,0); - } - public Alter_operator_family_stmtContext alter_operator_family_stmt() { - return getRuleContext(Alter_operator_family_stmtContext.class,0); - } - public Alter_policy_stmtContext alter_policy_stmt() { - return getRuleContext(Alter_policy_stmtContext.class,0); - } - public Alter_publication_stmtContext alter_publication_stmt() { - return getRuleContext(Alter_publication_stmtContext.class,0); - } - public Alter_role_stmtContext alter_role_stmt() { - return getRuleContext(Alter_role_stmtContext.class,0); - } - public Alter_rule_stmtContext alter_rule_stmt() { - return getRuleContext(Alter_rule_stmtContext.class,0); - } - public Alter_schema_stmtContext alter_schema_stmt() { - return getRuleContext(Alter_schema_stmtContext.class,0); - } - public Alter_sequence_stmtContext alter_sequence_stmt() { - return getRuleContext(Alter_sequence_stmtContext.class,0); - } - public Alter_server_stmtContext alter_server_stmt() { - return getRuleContext(Alter_server_stmtContext.class,0); - } - public Alter_statistics_stmtContext alter_statistics_stmt() { - return getRuleContext(Alter_statistics_stmtContext.class,0); - } - public Alter_subscription_stmtContext alter_subscription_stmt() { - return getRuleContext(Alter_subscription_stmtContext.class,0); - } - public Alter_system_stmtContext alter_system_stmt() { - return getRuleContext(Alter_system_stmtContext.class,0); - } - public Alter_table_stmtContext alter_table_stmt() { - return getRuleContext(Alter_table_stmtContext.class,0); - } - public Alter_tablespace_stmtContext alter_tablespace_stmt() { - return getRuleContext(Alter_tablespace_stmtContext.class,0); - } - public Alter_text_search_config_stmtContext alter_text_search_config_stmt() { - return getRuleContext(Alter_text_search_config_stmtContext.class,0); - } - public Alter_text_search_dict_stmtContext alter_text_search_dict_stmt() { - return getRuleContext(Alter_text_search_dict_stmtContext.class,0); - } - public Alter_text_search_parser_stmtContext alter_text_search_parser_stmt() { - return getRuleContext(Alter_text_search_parser_stmtContext.class,0); - } - public Alter_text_search_template_stmtContext alter_text_search_template_stmt() { - return getRuleContext(Alter_text_search_template_stmtContext.class,0); - } - public Alter_trigger_stmtContext alter_trigger_stmt() { - return getRuleContext(Alter_trigger_stmtContext.class,0); - } - public Alter_type_stmtContext alter_type_stmt() { - return getRuleContext(Alter_type_stmtContext.class,0); - } - public Alter_user_stmtContext alter_user_stmt() { - return getRuleContext(Alter_user_stmtContext.class,0); - } - public Alter_user_mapping_stmtContext alter_user_mapping_stmt() { - return getRuleContext(Alter_user_mapping_stmtContext.class,0); - } - public Alter_view_stmtContext alter_view_stmt() { - return getRuleContext(Alter_view_stmtContext.class,0); - } - public Alter_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_stmt(this); - } - } - - public final Alter_stmtContext alter_stmt() throws RecognitionException { - Alter_stmtContext _localctx = new Alter_stmtContext(_ctx, getState()); - enterRule(_localctx, 6, RULE_alter_stmt); - try { - setState(655); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(615); - alter_aggregate_stmt(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(616); - alter_collation_stmt(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(617); - alter_conversion_stmt(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(618); - alter_database_stmt(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(619); - alter_default_privileges_stmt(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(620); - alter_domain_stmt(); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(621); - alter_event_trigger_stmt(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(622); - alter_extension_stmt(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(623); - alter_foreign_data_wrapper_stmt(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(624); - alter_foreign_table_stmt(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(625); - alter_function_stmt(); - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(626); - alter_group_stmt(); - } - break; - case 13: - enterOuterAlt(_localctx, 13); - { - setState(627); - alter_index_stmt(); - } - break; - case 14: - enterOuterAlt(_localctx, 14); - { - setState(628); - alter_language_stmt(); - } - break; - case 15: - enterOuterAlt(_localctx, 15); - { - setState(629); - alter_large_object_stmt(); - } - break; - case 16: - enterOuterAlt(_localctx, 16); - { - setState(630); - alter_materialize_view_stmt(); - } - break; - case 17: - enterOuterAlt(_localctx, 17); - { - setState(631); - alter_operator_stmt(); - } - break; - case 18: - enterOuterAlt(_localctx, 18); - { - setState(632); - alter_operator_class_stmt(); - } - break; - case 19: - enterOuterAlt(_localctx, 19); - { - setState(633); - alter_operator_family_stmt(); - } - break; - case 20: - enterOuterAlt(_localctx, 20); - { - setState(634); - alter_policy_stmt(); - } - break; - case 21: - enterOuterAlt(_localctx, 21); - { - setState(635); - alter_publication_stmt(); - } - break; - case 22: - enterOuterAlt(_localctx, 22); - { - setState(636); - alter_role_stmt(); - } - break; - case 23: - enterOuterAlt(_localctx, 23); - { - setState(637); - alter_rule_stmt(); - } - break; - case 24: - enterOuterAlt(_localctx, 24); - { - setState(638); - alter_schema_stmt(); - } - break; - case 25: - enterOuterAlt(_localctx, 25); - { - setState(639); - alter_sequence_stmt(); - } - break; - case 26: - enterOuterAlt(_localctx, 26); - { - setState(640); - alter_server_stmt(); - } - break; - case 27: - enterOuterAlt(_localctx, 27); - { - setState(641); - alter_statistics_stmt(); - } - break; - case 28: - enterOuterAlt(_localctx, 28); - { - setState(642); - alter_subscription_stmt(); - } - break; - case 29: - enterOuterAlt(_localctx, 29); - { - setState(643); - alter_system_stmt(); - } - break; - case 30: - enterOuterAlt(_localctx, 30); - { - setState(644); - alter_table_stmt(); - } - break; - case 31: - enterOuterAlt(_localctx, 31); - { - setState(645); - alter_tablespace_stmt(); - } - break; - case 32: - enterOuterAlt(_localctx, 32); - { - setState(646); - alter_text_search_config_stmt(); - } - break; - case 33: - enterOuterAlt(_localctx, 33); - { - setState(647); - alter_text_search_dict_stmt(); - } - break; - case 34: - enterOuterAlt(_localctx, 34); - { - setState(648); - alter_text_search_parser_stmt(); - } - break; - case 35: - enterOuterAlt(_localctx, 35); - { - setState(649); - alter_text_search_template_stmt(); - } - break; - case 36: - enterOuterAlt(_localctx, 36); - { - setState(650); - alter_trigger_stmt(); - } - break; - case 37: - enterOuterAlt(_localctx, 37); - { - setState(651); - alter_type_stmt(); - } - break; - case 38: - enterOuterAlt(_localctx, 38); - { - setState(652); - alter_user_stmt(); - } - break; - case 39: - enterOuterAlt(_localctx, 39); - { - setState(653); - alter_user_mapping_stmt(); - } - break; - case 40: - enterOuterAlt(_localctx, 40); - { - setState(654); - alter_view_stmt(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_aggregate_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_name; - public Role_nameContext new_owner; - public IdentifierContext new_schema; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Aggregate_signatureContext aggregate_signature() { - return getRuleContext(Aggregate_signatureContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_aggregate_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_aggregate_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_aggregate_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_aggregate_stmt(this); - } - } - - public final Alter_aggregate_stmtContext alter_aggregate_stmt() throws RecognitionException { - Alter_aggregate_stmtContext _localctx = new Alter_aggregate_stmtContext(_ctx, getState()); - enterRule(_localctx, 8, RULE_alter_aggregate_stmt); - try { - setState(687); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(657); - match(ALTER); - setState(658); - match(AGGREGATE); - setState(659); - ((Alter_aggregate_stmtContext)_localctx).name = identifier(0); - setState(660); - match(OPEN_PAREN); - setState(661); - aggregate_signature(); - setState(662); - match(CLOSE_PAREN); - setState(663); - match(RENAME); - setState(664); - match(TO); - setState(665); - ((Alter_aggregate_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(667); - match(ALTER); - setState(668); - match(AGGREGATE); - setState(669); - ((Alter_aggregate_stmtContext)_localctx).name = identifier(0); - setState(670); - match(OPEN_PAREN); - setState(671); - aggregate_signature(); - setState(672); - match(CLOSE_PAREN); - setState(673); - match(OWNER); - setState(674); - match(TO); - setState(675); - ((Alter_aggregate_stmtContext)_localctx).new_owner = role_name(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(677); - match(ALTER); - setState(678); - match(AGGREGATE); - setState(679); - ((Alter_aggregate_stmtContext)_localctx).name = identifier(0); - setState(680); - match(OPEN_PAREN); - setState(681); - aggregate_signature(); - setState(682); - match(CLOSE_PAREN); - setState(683); - match(SET); - setState(684); - match(SCHEMA); - setState(685); - ((Alter_aggregate_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_collation_stmtContext extends ParserRuleContext { - public Name_Context name; - public IdentifierContext new_name; - public Role_nameContext new_owner; - public IdentifierContext new_schema; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } - public TerminalNode REFRESH() { return getToken(PostgreSqlParser.REFRESH, 0); } - public TerminalNode VERSION() { return getToken(PostgreSqlParser.VERSION, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_collation_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_collation_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_collation_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_collation_stmt(this); - } - } - - public final Alter_collation_stmtContext alter_collation_stmt() throws RecognitionException { - Alter_collation_stmtContext _localctx = new Alter_collation_stmtContext(_ctx, getState()); - enterRule(_localctx, 10, RULE_alter_collation_stmt); - try { - setState(716); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(689); - match(ALTER); - setState(690); - match(COLLATION); - setState(691); - ((Alter_collation_stmtContext)_localctx).name = name_(); - setState(692); - match(REFRESH); - setState(693); - match(VERSION); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(695); - match(ALTER); - setState(696); - match(COLLATION); - setState(697); - ((Alter_collation_stmtContext)_localctx).name = name_(); - setState(698); - match(RENAME); - setState(699); - match(TO); - setState(700); - ((Alter_collation_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(702); - match(ALTER); - setState(703); - match(COLLATION); - setState(704); - ((Alter_collation_stmtContext)_localctx).name = name_(); - setState(705); - match(OWNER); - setState(706); - match(TO); - setState(707); - ((Alter_collation_stmtContext)_localctx).new_owner = role_name(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(709); - match(ALTER); - setState(710); - match(COLLATION); - setState(711); - ((Alter_collation_stmtContext)_localctx).name = name_(); - setState(712); - match(SET); - setState(713); - match(SCHEMA); - setState(714); - ((Alter_collation_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_conversion_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_name; - public Role_nameContext new_owner; - public IdentifierContext new_schema; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode CONVERSION() { return getToken(PostgreSqlParser.CONVERSION, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_conversion_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_conversion_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_conversion_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_conversion_stmt(this); - } - } - - public final Alter_conversion_stmtContext alter_conversion_stmt() throws RecognitionException { - Alter_conversion_stmtContext _localctx = new Alter_conversion_stmtContext(_ctx, getState()); - enterRule(_localctx, 12, RULE_alter_conversion_stmt); - try { - setState(739); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(718); - match(ALTER); - setState(719); - match(CONVERSION); - setState(720); - ((Alter_conversion_stmtContext)_localctx).name = identifier(0); - setState(721); - match(RENAME); - setState(722); - match(TO); - setState(723); - ((Alter_conversion_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(725); - match(ALTER); - setState(726); - match(CONVERSION); - setState(727); - ((Alter_conversion_stmtContext)_localctx).name = identifier(0); - setState(728); - match(OWNER); - setState(729); - match(TO); - setState(730); - ((Alter_conversion_stmtContext)_localctx).new_owner = role_name(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(732); - match(ALTER); - setState(733); - match(CONVERSION); - setState(734); - ((Alter_conversion_stmtContext)_localctx).name = identifier(0); - setState(735); - match(SET); - setState(736); - match(SCHEMA); - setState(737); - ((Alter_conversion_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_database_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_database_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_database_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_database_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_database_stmt(this); - } - } - - public final Alter_database_stmtContext alter_database_stmt() throws RecognitionException { - Alter_database_stmtContext _localctx = new Alter_database_stmtContext(_ctx, getState()); - enterRule(_localctx, 14, RULE_alter_database_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(741); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_default_privileges_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_default_privileges_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_default_privileges_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_default_privileges_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_default_privileges_stmt(this); - } - } - - public final Alter_default_privileges_stmtContext alter_default_privileges_stmt() throws RecognitionException { - Alter_default_privileges_stmtContext _localctx = new Alter_default_privileges_stmtContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_alter_default_privileges_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(743); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_domain_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext constraint_name; - public IdentifierContext new_constraint_name; - public Role_nameContext new_owner; - public IdentifierContext new_name; - public IdentifierContext new_schema; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode DOMAIN() { return getToken(PostgreSqlParser.DOMAIN, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } - public ExprContext expr() { - return getRuleContext(ExprContext.class,0); - } - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode NULL() { return getToken(PostgreSqlParser.NULL, 0); } - public TerminalNode ADD() { return getToken(PostgreSqlParser.ADD, 0); } - public Domain_constraintContext domain_constraint() { - return getRuleContext(Domain_constraintContext.class,0); - } - public TerminalNode VALID() { return getToken(PostgreSqlParser.VALID, 0); } - public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode VALIDATE() { return getToken(PostgreSqlParser.VALIDATE, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_domain_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_domain_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_domain_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_domain_stmt(this); - } - } - - public final Alter_domain_stmtContext alter_domain_stmt() throws RecognitionException { - Alter_domain_stmtContext _localctx = new Alter_domain_stmtContext(_ctx, getState()); - enterRule(_localctx, 18, RULE_alter_domain_stmt); - int _la; - try { - setState(821); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(745); - match(ALTER); - setState(746); - match(DOMAIN); - setState(747); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(753); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SET: - { - setState(748); - match(SET); - setState(749); - match(DEFAULT); - setState(750); - expr(0); - } - break; - case DROP: - { - setState(751); - match(DROP); - setState(752); - match(DEFAULT); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(755); - match(ALTER); - setState(756); - match(DOMAIN); - setState(757); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(758); - _la = _input.LA(1); - if ( !(_la==DROP || _la==SET) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(759); - match(NOT); - setState(760); - match(NULL); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(762); - match(ALTER); - setState(763); - match(DOMAIN); - setState(764); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(765); - match(ADD); - setState(766); - domain_constraint(); - setState(769); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOT) { - { - setState(767); - match(NOT); - setState(768); - match(VALID); - } - } - - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(771); - match(ALTER); - setState(772); - match(DOMAIN); - setState(773); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(774); - match(DROP); - setState(775); - match(CONSTRAINT); - setState(778); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(776); - match(IF); - setState(777); - match(EXISTS); - } - } - - setState(780); - ((Alter_domain_stmtContext)_localctx).constraint_name = identifier(0); - setState(782); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(781); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(784); - match(ALTER); - setState(785); - match(DOMAIN); - setState(786); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(787); - match(RENAME); - setState(788); - match(CONSTRAINT); - setState(789); - ((Alter_domain_stmtContext)_localctx).constraint_name = identifier(0); - setState(790); - match(TO); - setState(791); - ((Alter_domain_stmtContext)_localctx).new_constraint_name = identifier(0); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(793); - match(ALTER); - setState(794); - match(DOMAIN); - setState(795); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(796); - match(VALIDATE); - setState(797); - match(CONSTRAINT); - setState(798); - ((Alter_domain_stmtContext)_localctx).constraint_name = identifier(0); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(800); - match(ALTER); - setState(801); - match(DOMAIN); - setState(802); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(803); - match(OWNER); - setState(804); - match(TO); - setState(805); - ((Alter_domain_stmtContext)_localctx).new_owner = role_name(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(807); - match(ALTER); - setState(808); - match(DOMAIN); - setState(809); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(810); - match(RENAME); - setState(811); - match(TO); - setState(812); - ((Alter_domain_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(814); - match(ALTER); - setState(815); - match(DOMAIN); - setState(816); - ((Alter_domain_stmtContext)_localctx).name = identifier(0); - setState(817); - match(SET); - setState(818); - match(SCHEMA); - setState(819); - ((Alter_domain_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_event_trigger_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_owner; - public IdentifierContext new_name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } - public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } - public TerminalNode DISABLE() { return getToken(PostgreSqlParser.DISABLE, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode ENABLE() { return getToken(PostgreSqlParser.ENABLE, 0); } - public TerminalNode REPLICA() { return getToken(PostgreSqlParser.REPLICA, 0); } - public TerminalNode ALWAYS() { return getToken(PostgreSqlParser.ALWAYS, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public Alter_event_trigger_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_event_trigger_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_event_trigger_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_event_trigger_stmt(this); - } - } - - public final Alter_event_trigger_stmtContext alter_event_trigger_stmt() throws RecognitionException { - Alter_event_trigger_stmtContext _localctx = new Alter_event_trigger_stmtContext(_ctx, getState()); - enterRule(_localctx, 20, RULE_alter_event_trigger_stmt); - int _la; - try { - setState(856); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(823); - match(ALTER); - setState(824); - match(EVENT); - setState(825); - match(TRIGGER); - setState(826); - ((Alter_event_trigger_stmtContext)_localctx).name = identifier(0); - setState(827); - match(DISABLE); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(829); - match(ALTER); - setState(830); - match(EVENT); - setState(831); - match(TRIGGER); - setState(832); - ((Alter_event_trigger_stmtContext)_localctx).name = identifier(0); - setState(833); - match(ENABLE); - setState(835); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ALWAYS || _la==REPLICA) { - { - setState(834); - _la = _input.LA(1); - if ( !(_la==ALWAYS || _la==REPLICA) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(837); - match(ALTER); - setState(838); - match(EVENT); - setState(839); - match(TRIGGER); - setState(840); - ((Alter_event_trigger_stmtContext)_localctx).name = identifier(0); - setState(841); - match(OWNER); - setState(842); - match(TO); - setState(846); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(843); - ((Alter_event_trigger_stmtContext)_localctx).new_owner = identifier(0); - } - break; - case CURRENT_USER: - { - setState(844); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(845); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(848); - match(ALTER); - setState(849); - match(EVENT); - setState(850); - match(TRIGGER); - setState(851); - ((Alter_event_trigger_stmtContext)_localctx).name = identifier(0); - setState(852); - match(RENAME); - setState(853); - match(TO); - setState(854); - ((Alter_event_trigger_stmtContext)_localctx).new_name = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_extension_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_version; - public IdentifierContext new_schema; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_extension_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_extension_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_extension_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_extension_stmt(this); - } - } - - public final Alter_extension_stmtContext alter_extension_stmt() throws RecognitionException { - Alter_extension_stmtContext _localctx = new Alter_extension_stmtContext(_ctx, getState()); - enterRule(_localctx, 22, RULE_alter_extension_stmt); - int _la; - try { - setState(873); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(858); - match(ALTER); - setState(859); - match(EXTENSION); - setState(860); - ((Alter_extension_stmtContext)_localctx).name = identifier(0); - setState(861); - match(UPDATE); - setState(864); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TO) { - { - setState(862); - match(TO); - setState(863); - ((Alter_extension_stmtContext)_localctx).new_version = identifier(0); - } - } - - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(866); - match(ALTER); - setState(867); - match(EXTENSION); - setState(868); - ((Alter_extension_stmtContext)_localctx).name = identifier(0); - setState(869); - match(SET); - setState(870); - match(SCHEMA); - setState(871); - ((Alter_extension_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_foreign_data_wrapper_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_foreign_data_wrapper_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_foreign_data_wrapper_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_foreign_data_wrapper_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_foreign_data_wrapper_stmt(this); - } - } - - public final Alter_foreign_data_wrapper_stmtContext alter_foreign_data_wrapper_stmt() throws RecognitionException { - Alter_foreign_data_wrapper_stmtContext _localctx = new Alter_foreign_data_wrapper_stmtContext(_ctx, getState()); - enterRule(_localctx, 24, RULE_alter_foreign_data_wrapper_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(875); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_foreign_table_actionContext extends ParserRuleContext { - public Column_nameContext column_name_; - public Data_typeContext data_type_; - public IdentifierContext collation; - public Column_constraintsContext column_constraints_; - public Option_listContext attribute_values; - public Identifier_listContext attributes; - public Todo_fill_inContext constraint_name; - public Todo_fill_inContext trigger_name; - public IdentifierContext parent_table; - public Role_nameContext new_owner; - public TerminalNode ADD() { return getToken(PostgreSqlParser.ADD, 0); } - public Column_nameContext column_name() { - return getRuleContext(Column_nameContext.class,0); - } - public Data_typeContext data_type() { - return getRuleContext(Data_typeContext.class,0); - } - public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } - public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Column_constraintsContext column_constraints() { - return getRuleContext(Column_constraintsContext.class,0); - } - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode TYPE() { return getToken(PostgreSqlParser.TYPE, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode DATA() { return getToken(PostgreSqlParser.DATA, 0); } - public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } - public ExprContext expr() { - return getRuleContext(ExprContext.class,0); - } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode NULL() { return getToken(PostgreSqlParser.NULL, 0); } - public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } - public TerminalNode INTEGER() { return getToken(PostgreSqlParser.INTEGER, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Option_listContext option_list() { - return getRuleContext(Option_listContext.class,0); - } - public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode STORAGE() { return getToken(PostgreSqlParser.STORAGE, 0); } - public TerminalNode PLAIN() { return getToken(PostgreSqlParser.PLAIN, 0); } - public TerminalNode EXTERNAL() { return getToken(PostgreSqlParser.EXTERNAL, 0); } - public TerminalNode EXTENDED() { return getToken(PostgreSqlParser.EXTENDED, 0); } - public TerminalNode MAIN() { return getToken(PostgreSqlParser.MAIN, 0); } - public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } - public Table_constraintContext table_constraint() { - return getRuleContext(Table_constraintContext.class,0); - } - public TerminalNode VALID() { return getToken(PostgreSqlParser.VALID, 0); } - public TerminalNode VALIDATE() { return getToken(PostgreSqlParser.VALIDATE, 0); } - public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } - public Todo_fill_inContext todo_fill_in() { - return getRuleContext(Todo_fill_inContext.class,0); - } - public TerminalNode DISABLE() { return getToken(PostgreSqlParser.DISABLE, 0); } - public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } - public TerminalNode ENABLE() { return getToken(PostgreSqlParser.ENABLE, 0); } - public TerminalNode REPLICA() { return getToken(PostgreSqlParser.REPLICA, 0); } - public TerminalNode ALWAYS() { return getToken(PostgreSqlParser.ALWAYS, 0); } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode OIDS() { return getToken(PostgreSqlParser.OIDS, 0); } - public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } - public TerminalNode INHERIT() { return getToken(PostgreSqlParser.INHERIT, 0); } - public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public Alter_foreign_table_actionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_foreign_table_action; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_foreign_table_action(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_foreign_table_action(this); - } - } - - public final Alter_foreign_table_actionContext alter_foreign_table_action() throws RecognitionException { - Alter_foreign_table_actionContext _localctx = new Alter_foreign_table_actionContext(_ctx, getState()); - enterRule(_localctx, 26, RULE_alter_foreign_table_action); - int _la; - try { - setState(1049); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(877); - match(ADD); - setState(879); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(878); - match(COLUMN); - } - } - - setState(881); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(882); - ((Alter_foreign_table_actionContext)_localctx).data_type_ = data_type(); - setState(885); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLLATE) { - { - setState(883); - match(COLLATE); - setState(884); - ((Alter_foreign_table_actionContext)_localctx).collation = identifier(0); - } - } - - setState(888); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOT) { - { - setState(887); - ((Alter_foreign_table_actionContext)_localctx).column_constraints_ = column_constraints(); - } - } - - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(890); - match(DROP); - setState(892); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(891); - match(COLUMN); - } - } - - setState(896); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(894); - match(IF); - setState(895); - match(EXISTS); - } - } - - setState(898); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(900); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(899); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(902); - match(ALTER); - setState(904); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(903); - match(COLUMN); - } - } - - setState(906); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(909); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SET) { - { - setState(907); - match(SET); - setState(908); - match(DATA); - } - } - - setState(911); - match(TYPE); - setState(912); - ((Alter_foreign_table_actionContext)_localctx).data_type_ = data_type(); - setState(915); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLLATE) { - { - setState(913); - match(COLLATE); - setState(914); - ((Alter_foreign_table_actionContext)_localctx).collation = identifier(0); - } - } - - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(917); - match(ALTER); - setState(919); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(918); - match(COLUMN); - } - } - - setState(921); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(922); - match(SET); - setState(923); - match(DEFAULT); - setState(924); - expr(0); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(926); - match(ALTER); - setState(928); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(927); - match(COLUMN); - } - } - - setState(930); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(931); - match(DROP); - setState(932); - match(DEFAULT); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(934); - match(ALTER); - setState(936); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(935); - match(COLUMN); - } - } - - setState(938); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(939); - _la = _input.LA(1); - if ( !(_la==DROP || _la==SET) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(940); - match(NOT); - setState(941); - match(NULL); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(943); - match(ALTER); - setState(945); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(944); - match(COLUMN); - } - } - - setState(947); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(948); - match(SET); - setState(949); - match(STATISTICS); - setState(950); - match(INTEGER); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(952); - match(ALTER); - setState(954); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(953); - match(COLUMN); - } - } - - setState(956); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(957); - match(SET); - setState(958); - match(OPEN_PAREN); - setState(959); - ((Alter_foreign_table_actionContext)_localctx).attribute_values = option_list(); - setState(960); - match(CLOSE_PAREN); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(962); - match(ALTER); - setState(964); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(963); - match(COLUMN); - } - } - - setState(966); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(967); - match(RESET); - setState(968); - match(OPEN_PAREN); - setState(969); - ((Alter_foreign_table_actionContext)_localctx).attributes = identifier_list(); - setState(970); - match(CLOSE_PAREN); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(972); - match(ALTER); - setState(974); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(973); - match(COLUMN); - } - } - - setState(976); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(977); - match(SET); - setState(978); - match(STORAGE); - setState(979); - _la = _input.LA(1); - if ( !(_la==EXTENDED || _la==EXTERNAL || _la==MAIN || _la==PLAIN) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(981); - match(ALTER); - setState(983); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(982); - match(COLUMN); - } - } - - setState(985); - ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); - setState(986); - match(OPTIONS); - { - setState(988); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ADD || _la==DROP || _la==SET) { - { - setState(987); - _la = _input.LA(1); - if ( !(_la==ADD || _la==DROP || _la==SET) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(990); - match(ADD); - setState(991); - table_constraint(); - setState(994); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOT) { - { - setState(992); - match(NOT); - setState(993); - match(VALID); - } - } - - } - break; - case 13: - enterOuterAlt(_localctx, 13); - { - setState(996); - match(VALIDATE); - setState(997); - match(CONSTRAINT); - setState(998); - ((Alter_foreign_table_actionContext)_localctx).constraint_name = todo_fill_in(); - } - break; - case 14: - enterOuterAlt(_localctx, 14); - { - setState(999); - match(DROP); - setState(1000); - match(CONSTRAINT); - setState(1003); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { - case 1: - { - setState(1001); - match(IF); - setState(1002); - match(EXISTS); - } - break; - } - setState(1005); - ((Alter_foreign_table_actionContext)_localctx).constraint_name = todo_fill_in(); - setState(1007); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(1006); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - break; - case 15: - enterOuterAlt(_localctx, 15); - { - setState(1009); - match(DISABLE); - setState(1010); - match(TRIGGER); - setState(1014); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { - case 1: - { - setState(1011); - ((Alter_foreign_table_actionContext)_localctx).trigger_name = todo_fill_in(); - } - break; - case 2: - { - setState(1012); - match(ALL); - } - break; - case 3: - { - setState(1013); - match(USER); - } - break; - } - } - break; - case 16: - enterOuterAlt(_localctx, 16); - { - setState(1016); - match(ENABLE); - setState(1017); - match(TRIGGER); - setState(1021); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { - case 1: - { - setState(1018); - ((Alter_foreign_table_actionContext)_localctx).trigger_name = todo_fill_in(); - } - break; - case 2: - { - setState(1019); - match(ALL); - } - break; - case 3: - { - setState(1020); - match(USER); - } - break; - } - } - break; - case 17: - enterOuterAlt(_localctx, 17); - { - setState(1023); - match(ENABLE); - setState(1024); - match(REPLICA); - setState(1025); - match(TRIGGER); - setState(1026); - ((Alter_foreign_table_actionContext)_localctx).trigger_name = todo_fill_in(); - } - break; - case 18: - enterOuterAlt(_localctx, 18); - { - setState(1027); - match(ENABLE); - setState(1028); - match(ALWAYS); - setState(1029); - match(TRIGGER); - setState(1030); - ((Alter_foreign_table_actionContext)_localctx).trigger_name = todo_fill_in(); - } - break; - case 19: - enterOuterAlt(_localctx, 19); - { - setState(1031); - match(SET); - setState(1032); - match(WITH); - setState(1033); - match(OIDS); - } - break; - case 20: - enterOuterAlt(_localctx, 20); - { - setState(1034); - match(SET); - setState(1035); - match(WITHOUT); - setState(1036); - match(OIDS); - } - break; - case 21: - enterOuterAlt(_localctx, 21); - { - setState(1037); - match(INHERIT); - setState(1038); - ((Alter_foreign_table_actionContext)_localctx).parent_table = identifier(0); - } - break; - case 22: - enterOuterAlt(_localctx, 22); - { - setState(1039); - match(NO); - setState(1040); - match(INHERIT); - setState(1041); - ((Alter_foreign_table_actionContext)_localctx).parent_table = identifier(0); - } - break; - case 23: - enterOuterAlt(_localctx, 23); - { - setState(1042); - match(OWNER); - setState(1043); - match(TO); - setState(1044); - ((Alter_foreign_table_actionContext)_localctx).new_owner = role_name(); - } - break; - case 24: - enterOuterAlt(_localctx, 24); - { - setState(1045); - match(OPTIONS); - { - setState(1047); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ADD || _la==DROP || _la==SET) { - { - setState(1046); - _la = _input.LA(1); - if ( !(_la==ADD || _la==DROP || _la==SET) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_foreign_table_action_listContext extends ParserRuleContext { - public List alter_foreign_table_action() { - return getRuleContexts(Alter_foreign_table_actionContext.class); - } - public Alter_foreign_table_actionContext alter_foreign_table_action(int i) { - return getRuleContext(Alter_foreign_table_actionContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Alter_foreign_table_action_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_foreign_table_action_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_foreign_table_action_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_foreign_table_action_list(this); - } - } - - public final Alter_foreign_table_action_listContext alter_foreign_table_action_list() throws RecognitionException { - Alter_foreign_table_action_listContext _localctx = new Alter_foreign_table_action_listContext(_ctx, getState()); - enterRule(_localctx, 28, RULE_alter_foreign_table_action_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1051); - alter_foreign_table_action(); - setState(1056); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1052); - match(COMMA); - setState(1053); - alter_foreign_table_action(); - } - } - setState(1058); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_foreign_table_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public Alter_foreign_table_action_listContext actions; - public Column_nameContext column_name_; - public IdentifierContext new_column_name; - public IdentifierContext new_name; - public IdentifierContext new_schama; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public Alter_foreign_table_action_listContext alter_foreign_table_action_list() { - return getRuleContext(Alter_foreign_table_action_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public Column_nameContext column_name() { - return getRuleContext(Column_nameContext.class,0); - } - public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_foreign_table_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_foreign_table_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_foreign_table_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_foreign_table_stmt(this); - } - } - - public final Alter_foreign_table_stmtContext alter_foreign_table_stmt() throws RecognitionException { - Alter_foreign_table_stmtContext _localctx = new Alter_foreign_table_stmtContext(_ctx, getState()); - enterRule(_localctx, 30, RULE_alter_foreign_table_stmt); - int _la; - try { - setState(1121); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1059); - match(ALTER); - setState(1060); - match(FOREIGN); - setState(1061); - match(TABLE); - setState(1064); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1062); - match(IF); - setState(1063); - match(EXISTS); - } - } - - setState(1067); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(1066); - match(ONLY); - } - } - - setState(1069); - ((Alter_foreign_table_stmtContext)_localctx).name = identifier(0); - setState(1071); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==STAR) { - { - setState(1070); - match(STAR); - } - } - - setState(1073); - ((Alter_foreign_table_stmtContext)_localctx).actions = alter_foreign_table_action_list(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1075); - match(ALTER); - setState(1076); - match(FOREIGN); - setState(1077); - match(TABLE); - setState(1080); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1078); - match(IF); - setState(1079); - match(EXISTS); - } - } - - setState(1083); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(1082); - match(ONLY); - } - } - - setState(1085); - ((Alter_foreign_table_stmtContext)_localctx).name = identifier(0); - setState(1087); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==STAR) { - { - setState(1086); - match(STAR); - } - } - - setState(1089); - match(RENAME); - setState(1091); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLUMN) { - { - setState(1090); - match(COLUMN); - } - } - - setState(1093); - ((Alter_foreign_table_stmtContext)_localctx).column_name_ = column_name(); - setState(1094); - match(TO); - setState(1095); - ((Alter_foreign_table_stmtContext)_localctx).new_column_name = identifier(0); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1097); - match(ALTER); - setState(1098); - match(FOREIGN); - setState(1099); - match(TABLE); - setState(1102); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1100); - match(IF); - setState(1101); - match(EXISTS); - } - } - - setState(1104); - ((Alter_foreign_table_stmtContext)_localctx).name = identifier(0); - setState(1105); - match(RENAME); - setState(1106); - match(TO); - setState(1107); - ((Alter_foreign_table_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1109); - match(ALTER); - setState(1110); - match(FOREIGN); - setState(1111); - match(TABLE); - setState(1114); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1112); - match(IF); - setState(1113); - match(EXISTS); - } - } - - setState(1116); - ((Alter_foreign_table_stmtContext)_localctx).name = identifier(0); - setState(1117); - match(SET); - setState(1118); - match(SCHEMA); - setState(1119); - ((Alter_foreign_table_stmtContext)_localctx).new_schama = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_function_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_function_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_function_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_function_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_function_stmt(this); - } - } - - public final Alter_function_stmtContext alter_function_stmt() throws RecognitionException { - Alter_function_stmtContext _localctx = new Alter_function_stmtContext(_ctx, getState()); - enterRule(_localctx, 32, RULE_alter_function_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1123); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_group_stmtContext extends ParserRuleContext { - public Role_nameContext role; - public Identifier_listContext users; - public IdentifierContext group_name; - public IdentifierContext new_name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode GROUP() { return getToken(PostgreSqlParser.GROUP, 0); } - public TerminalNode ADD() { return getToken(PostgreSqlParser.ADD, 0); } - public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public Alter_group_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_group_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_group_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_group_stmt(this); - } - } - - public final Alter_group_stmtContext alter_group_stmt() throws RecognitionException { - Alter_group_stmtContext _localctx = new Alter_group_stmtContext(_ctx, getState()); - enterRule(_localctx, 34, RULE_alter_group_stmt); - try { - setState(1146); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1125); - match(ALTER); - setState(1126); - match(GROUP); - setState(1127); - ((Alter_group_stmtContext)_localctx).role = role_name(); - setState(1128); - match(ADD); - setState(1129); - match(USER); - setState(1130); - ((Alter_group_stmtContext)_localctx).users = identifier_list(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1132); - match(ALTER); - setState(1133); - match(GROUP); - setState(1134); - ((Alter_group_stmtContext)_localctx).role = role_name(); - setState(1135); - match(DROP); - setState(1136); - match(USER); - setState(1137); - ((Alter_group_stmtContext)_localctx).users = identifier_list(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1139); - match(ALTER); - setState(1140); - match(GROUP); - setState(1141); - ((Alter_group_stmtContext)_localctx).group_name = identifier(0); - setState(1142); - match(RENAME); - setState(1143); - match(TO); - setState(1144); - ((Alter_group_stmtContext)_localctx).new_name = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_index_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_name; - public IdentifierContext tablespace_name; - public IdentifierContext extension_name; - public Identifier_listContext roles; - public IdentifierContext new_tablespace; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public List TABLESPACE() { return getTokens(PostgreSqlParser.TABLESPACE); } - public TerminalNode TABLESPACE(int i) { - return getToken(PostgreSqlParser.TABLESPACE, i); - } - public TerminalNode DEPENDS() { return getToken(PostgreSqlParser.DEPENDS, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Option_listContext option_list() { - return getRuleContext(Option_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public TerminalNode IN() { return getToken(PostgreSqlParser.IN, 0); } - public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public TerminalNode NOWAIT() { return getToken(PostgreSqlParser.NOWAIT, 0); } - public Alter_index_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_index_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_index_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_index_stmt(this); - } - } - - public final Alter_index_stmtContext alter_index_stmt() throws RecognitionException { - Alter_index_stmtContext _localctx = new Alter_index_stmtContext(_ctx, getState()); - enterRule(_localctx, 36, RULE_alter_index_stmt); - int _la; - try { - setState(1218); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1148); - match(ALTER); - setState(1149); - match(INDEX); - setState(1152); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1150); - match(IF); - setState(1151); - match(EXISTS); - } - } - - setState(1154); - ((Alter_index_stmtContext)_localctx).name = identifier(0); - setState(1155); - match(RENAME); - setState(1156); - match(TO); - setState(1157); - ((Alter_index_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1159); - match(ALTER); - setState(1160); - match(INDEX); - setState(1163); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1161); - match(IF); - setState(1162); - match(EXISTS); - } - } - - setState(1165); - ((Alter_index_stmtContext)_localctx).name = identifier(0); - setState(1166); - match(SET); - setState(1167); - match(TABLESPACE); - setState(1168); - ((Alter_index_stmtContext)_localctx).tablespace_name = identifier(0); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1170); - match(ALTER); - setState(1171); - match(INDEX); - setState(1172); - ((Alter_index_stmtContext)_localctx).name = identifier(0); - setState(1173); - match(DEPENDS); - setState(1174); - match(ON); - setState(1175); - match(EXTENSION); - setState(1176); - ((Alter_index_stmtContext)_localctx).extension_name = identifier(0); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1178); - match(ALTER); - setState(1179); - match(INDEX); - setState(1182); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1180); - match(IF); - setState(1181); - match(EXISTS); - } - } - - setState(1184); - ((Alter_index_stmtContext)_localctx).name = identifier(0); - setState(1185); - match(SET); - setState(1186); - match(OPEN_PAREN); - setState(1187); - option_list(); - setState(1188); - match(CLOSE_PAREN); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1190); - match(ALTER); - setState(1191); - match(INDEX); - setState(1194); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1192); - match(IF); - setState(1193); - match(EXISTS); - } - } - - setState(1196); - match(RESET); - setState(1197); - match(OPEN_PAREN); - setState(1198); - identifier_list(); - setState(1199); - match(CLOSE_PAREN); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1201); - match(ALTER); - setState(1202); - match(INDEX); - setState(1203); - match(ALL); - setState(1204); - match(IN); - setState(1205); - match(TABLESPACE); - setState(1206); - ((Alter_index_stmtContext)_localctx).name = identifier(0); - setState(1210); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OWNED) { - { - setState(1207); - match(OWNED); - setState(1208); - match(BY); - setState(1209); - ((Alter_index_stmtContext)_localctx).roles = identifier_list(); - } - } - - setState(1212); - match(SET); - setState(1213); - match(TABLESPACE); - setState(1214); - ((Alter_index_stmtContext)_localctx).new_tablespace = identifier(0); - setState(1216); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOWAIT) { - { - setState(1215); - match(NOWAIT); - } - } - - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_language_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_name; - public IdentifierContext new_owner; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode PROCEDURAL() { return getToken(PostgreSqlParser.PROCEDURAL, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public Alter_language_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_language_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_language_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_language_stmt(this); - } - } - - public final Alter_language_stmtContext alter_language_stmt() throws RecognitionException { - Alter_language_stmtContext _localctx = new Alter_language_stmtContext(_ctx, getState()); - enterRule(_localctx, 38, RULE_alter_language_stmt); - int _la; - try { - setState(1243); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1220); - match(ALTER); - setState(1222); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PROCEDURAL) { - { - setState(1221); - match(PROCEDURAL); - } - } - - setState(1224); - match(LANGUAGE); - setState(1225); - ((Alter_language_stmtContext)_localctx).name = identifier(0); - setState(1226); - match(RENAME); - setState(1227); - match(TO); - setState(1228); - ((Alter_language_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1230); - match(ALTER); - setState(1232); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PROCEDURAL) { - { - setState(1231); - match(PROCEDURAL); - } - } - - setState(1234); - match(LANGUAGE); - setState(1235); - ((Alter_language_stmtContext)_localctx).name = identifier(0); - setState(1236); - match(OWNER); - setState(1237); - match(TO); - setState(1241); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1238); - ((Alter_language_stmtContext)_localctx).new_owner = identifier(0); - } - break; - case CURRENT_USER: - { - setState(1239); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(1240); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_large_object_stmtContext extends ParserRuleContext { - public Token large_object_oid; - public IdentifierContext new_owner; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode LARGE() { return getToken(PostgreSqlParser.LARGE, 0); } - public TerminalNode OBJECT() { return getToken(PostgreSqlParser.OBJECT, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Alter_large_object_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_large_object_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_large_object_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_large_object_stmt(this); - } - } - - public final Alter_large_object_stmtContext alter_large_object_stmt() throws RecognitionException { - Alter_large_object_stmtContext _localctx = new Alter_large_object_stmtContext(_ctx, getState()); - enterRule(_localctx, 40, RULE_alter_large_object_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1245); - match(ALTER); - setState(1246); - match(LARGE); - setState(1247); - match(OBJECT); - setState(1248); - ((Alter_large_object_stmtContext)_localctx).large_object_oid = match(INTEGER_LITERAL); - setState(1249); - match(OWNER); - setState(1250); - match(TO); - setState(1254); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1251); - ((Alter_large_object_stmtContext)_localctx).new_owner = identifier(0); - } - break; - case CURRENT_USER: - { - setState(1252); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(1253); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_materialize_view_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_materialize_view_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_materialize_view_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_materialize_view_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_materialize_view_stmt(this); - } - } - - public final Alter_materialize_view_stmtContext alter_materialize_view_stmt() throws RecognitionException { - Alter_materialize_view_stmtContext _localctx = new Alter_materialize_view_stmtContext(_ctx, getState()); - enterRule(_localctx, 42, RULE_alter_materialize_view_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1256); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_operator_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_operator_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_operator_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_operator_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_operator_stmt(this); - } - } - - public final Alter_operator_stmtContext alter_operator_stmt() throws RecognitionException { - Alter_operator_stmtContext _localctx = new Alter_operator_stmtContext(_ctx, getState()); - enterRule(_localctx, 44, RULE_alter_operator_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1258); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_operator_class_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_name; - public IdentifierContext new_owner; - public IdentifierContext new_schema; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } - public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public Index_methodContext index_method() { - return getRuleContext(Index_methodContext.class,0); - } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_operator_class_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_operator_class_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_operator_class_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_operator_class_stmt(this); - } - } - - public final Alter_operator_class_stmtContext alter_operator_class_stmt() throws RecognitionException { - Alter_operator_class_stmtContext _localctx = new Alter_operator_class_stmtContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_alter_operator_class_stmt); - try { - setState(1293); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1260); - match(ALTER); - setState(1261); - match(OPERATOR); - setState(1262); - match(CLASS); - setState(1263); - ((Alter_operator_class_stmtContext)_localctx).name = identifier(0); - setState(1264); - match(USING); - setState(1265); - index_method(); - setState(1266); - match(RENAME); - setState(1267); - match(TO); - setState(1268); - ((Alter_operator_class_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1270); - match(ALTER); - setState(1271); - match(OPERATOR); - setState(1272); - match(CLASS); - setState(1273); - ((Alter_operator_class_stmtContext)_localctx).name = identifier(0); - setState(1274); - match(USING); - setState(1275); - index_method(); - setState(1276); - match(OWNER); - setState(1277); - match(TO); - setState(1281); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1278); - ((Alter_operator_class_stmtContext)_localctx).new_owner = identifier(0); - } - break; - case CURRENT_USER: - { - setState(1279); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(1280); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1283); - match(ALTER); - setState(1284); - match(OPERATOR); - setState(1285); - match(CLASS); - setState(1286); - ((Alter_operator_class_stmtContext)_localctx).name = identifier(0); - setState(1287); - match(USING); - setState(1288); - index_method(); - setState(1289); - match(SET); - setState(1290); - match(SCHEMA); - setState(1291); - ((Alter_operator_class_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_operator_family_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_operator_family_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_operator_family_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_operator_family_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_operator_family_stmt(this); - } - } - - public final Alter_operator_family_stmtContext alter_operator_family_stmt() throws RecognitionException { - Alter_operator_family_stmtContext _localctx = new Alter_operator_family_stmtContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_alter_operator_family_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1295); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_policy_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext table_name; - public IdentifierContext new_name; - public Role_name_listContext roles; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode POLICY() { return getToken(PostgreSqlParser.POLICY, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public List predicate() { - return getRuleContexts(PredicateContext.class); - } - public PredicateContext predicate(int i) { - return getRuleContext(PredicateContext.class,i); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } - public Role_name_listContext role_name_list() { - return getRuleContext(Role_name_listContext.class,0); - } - public Alter_policy_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_policy_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_policy_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_policy_stmt(this); - } - } - - public final Alter_policy_stmtContext alter_policy_stmt() throws RecognitionException { - Alter_policy_stmtContext _localctx = new Alter_policy_stmtContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_alter_policy_stmt); - int _la; - try { - setState(1324); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1297); - match(ALTER); - setState(1298); - match(POLICY); - setState(1299); - ((Alter_policy_stmtContext)_localctx).name = identifier(0); - setState(1300); - match(ON); - setState(1301); - ((Alter_policy_stmtContext)_localctx).table_name = identifier(0); - setState(1302); - match(RENAME); - setState(1303); - match(TO); - setState(1304); - ((Alter_policy_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1306); - match(ALTER); - setState(1307); - match(POLICY); - setState(1308); - ((Alter_policy_stmtContext)_localctx).name = identifier(0); - setState(1309); - match(ON); - setState(1310); - ((Alter_policy_stmtContext)_localctx).table_name = identifier(0); - setState(1313); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TO) { - { - setState(1311); - match(TO); - setState(1312); - ((Alter_policy_stmtContext)_localctx).roles = role_name_list(); - } - } - - setState(1317); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==USING) { - { - setState(1315); - match(USING); - setState(1316); - predicate(0); - } - } - - setState(1322); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(1319); - match(WITH); - setState(1320); - match(CHECK); - setState(1321); - predicate(0); - } - } - - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_publication_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public Identifier_listContext table_names; - public Role_nameContext new_owner; - public Name_Context new_name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } - public TerminalNode ADD() { return getToken(PostgreSqlParser.ADD, 0); } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Option_listContext option_list() { - return getRuleContext(Option_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public Alter_publication_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_publication_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_publication_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_publication_stmt(this); - } - } - - public final Alter_publication_stmtContext alter_publication_stmt() throws RecognitionException { - Alter_publication_stmtContext _localctx = new Alter_publication_stmtContext(_ctx, getState()); - enterRule(_localctx, 52, RULE_alter_publication_stmt); - int _la; - try { - setState(1378); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1326); - match(ALTER); - setState(1327); - match(PUBLICATION); - setState(1328); - ((Alter_publication_stmtContext)_localctx).name = identifier(0); - setState(1329); - match(ADD); - setState(1330); - match(TABLE); - setState(1332); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(1331); - match(ONLY); - } - } - - setState(1334); - ((Alter_publication_stmtContext)_localctx).table_names = identifier_list(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1336); - match(ALTER); - setState(1337); - match(PUBLICATION); - setState(1338); - ((Alter_publication_stmtContext)_localctx).name = identifier(0); - setState(1339); - match(SET); - setState(1340); - match(TABLE); - setState(1342); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(1341); - match(ONLY); - } - } - - setState(1344); - ((Alter_publication_stmtContext)_localctx).table_names = identifier_list(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1346); - match(ALTER); - setState(1347); - match(PUBLICATION); - setState(1348); - ((Alter_publication_stmtContext)_localctx).name = identifier(0); - setState(1349); - match(DROP); - setState(1350); - match(TABLE); - setState(1352); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(1351); - match(ONLY); - } - } - - setState(1354); - ((Alter_publication_stmtContext)_localctx).table_names = identifier_list(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1356); - match(ALTER); - setState(1357); - match(PUBLICATION); - setState(1358); - ((Alter_publication_stmtContext)_localctx).name = identifier(0); - setState(1359); - match(SET); - setState(1360); - match(OPEN_PAREN); - setState(1361); - option_list(); - setState(1362); - match(CLOSE_PAREN); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1364); - match(ALTER); - setState(1365); - match(PUBLICATION); - setState(1366); - ((Alter_publication_stmtContext)_localctx).name = identifier(0); - setState(1367); - match(OWNER); - setState(1368); - match(TO); - setState(1369); - ((Alter_publication_stmtContext)_localctx).new_owner = role_name(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1371); - match(ALTER); - setState(1372); - match(PUBLICATION); - setState(1373); - ((Alter_publication_stmtContext)_localctx).name = identifier(0); - setState(1374); - match(RENAME); - setState(1375); - match(TO); - setState(1376); - ((Alter_publication_stmtContext)_localctx).new_name = name_(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_role_optionsContext extends ParserRuleContext { - public Token connlimit; - public TerminalNode SUPERUSER() { return getToken(PostgreSqlParser.SUPERUSER, 0); } - public TerminalNode NOSUPERUSER() { return getToken(PostgreSqlParser.NOSUPERUSER, 0); } - public TerminalNode CREATEDB() { return getToken(PostgreSqlParser.CREATEDB, 0); } - public TerminalNode NOCREATEDB() { return getToken(PostgreSqlParser.NOCREATEDB, 0); } - public TerminalNode CREATEROLE() { return getToken(PostgreSqlParser.CREATEROLE, 0); } - public TerminalNode NOCREATEROLE() { return getToken(PostgreSqlParser.NOCREATEROLE, 0); } - public TerminalNode INHERIT() { return getToken(PostgreSqlParser.INHERIT, 0); } - public TerminalNode NOINHERIT() { return getToken(PostgreSqlParser.NOINHERIT, 0); } - public TerminalNode LOGIN() { return getToken(PostgreSqlParser.LOGIN, 0); } - public TerminalNode NOLOGIN() { return getToken(PostgreSqlParser.NOLOGIN, 0); } - public TerminalNode REPLICATION() { return getToken(PostgreSqlParser.REPLICATION, 0); } - public TerminalNode NOREPLICATION() { return getToken(PostgreSqlParser.NOREPLICATION, 0); } - public TerminalNode BYPASSRLS() { return getToken(PostgreSqlParser.BYPASSRLS, 0); } - public TerminalNode NOBYPASSRLS() { return getToken(PostgreSqlParser.NOBYPASSRLS, 0); } - public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } - public TerminalNode LIMIT() { return getToken(PostgreSqlParser.LIMIT, 0); } - public TerminalNode INTEGER() { return getToken(PostgreSqlParser.INTEGER, 0); } - public TerminalNode PASSWORD() { return getToken(PostgreSqlParser.PASSWORD, 0); } - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public TerminalNode ENCRYPTED() { return getToken(PostgreSqlParser.ENCRYPTED, 0); } - public TerminalNode VALID() { return getToken(PostgreSqlParser.VALID, 0); } - public TerminalNode UNTIL() { return getToken(PostgreSqlParser.UNTIL, 0); } - public Alter_role_optionsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_role_options; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_role_options(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_role_options(this); - } - } - - public final Alter_role_optionsContext alter_role_options() throws RecognitionException { - Alter_role_optionsContext _localctx = new Alter_role_optionsContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_alter_role_options); - int _la; - try { - setState(1405); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SUPERUSER: - enterOuterAlt(_localctx, 1); - { - setState(1380); - match(SUPERUSER); - } - break; - case NOSUPERUSER: - enterOuterAlt(_localctx, 2); - { - setState(1381); - match(NOSUPERUSER); - } - break; - case CREATEDB: - enterOuterAlt(_localctx, 3); - { - setState(1382); - match(CREATEDB); - } - break; - case NOCREATEDB: - enterOuterAlt(_localctx, 4); - { - setState(1383); - match(NOCREATEDB); - } - break; - case CREATEROLE: - enterOuterAlt(_localctx, 5); - { - setState(1384); - match(CREATEROLE); - } - break; - case NOCREATEROLE: - enterOuterAlt(_localctx, 6); - { - setState(1385); - match(NOCREATEROLE); - } - break; - case INHERIT: - enterOuterAlt(_localctx, 7); - { - setState(1386); - match(INHERIT); - } - break; - case NOINHERIT: - enterOuterAlt(_localctx, 8); - { - setState(1387); - match(NOINHERIT); - } - break; - case LOGIN: - enterOuterAlt(_localctx, 9); - { - setState(1388); - match(LOGIN); - } - break; - case NOLOGIN: - enterOuterAlt(_localctx, 10); - { - setState(1389); - match(NOLOGIN); - } - break; - case REPLICATION: - enterOuterAlt(_localctx, 11); - { - setState(1390); - match(REPLICATION); - } - break; - case NOREPLICATION: - enterOuterAlt(_localctx, 12); - { - setState(1391); - match(NOREPLICATION); - } - break; - case BYPASSRLS: - enterOuterAlt(_localctx, 13); - { - setState(1392); - match(BYPASSRLS); - } - break; - case NOBYPASSRLS: - enterOuterAlt(_localctx, 14); - { - setState(1393); - match(NOBYPASSRLS); - } - break; - case CONNECTION: - enterOuterAlt(_localctx, 15); - { - setState(1394); - match(CONNECTION); - setState(1395); - match(LIMIT); - setState(1396); - ((Alter_role_optionsContext)_localctx).connlimit = match(INTEGER); - } - break; - case ENCRYPTED: - case PASSWORD: - enterOuterAlt(_localctx, 16); - { - setState(1398); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ENCRYPTED) { - { - setState(1397); - match(ENCRYPTED); - } - } - - setState(1400); - match(PASSWORD); - setState(1401); - match(SINGLEQ_STRING_LITERAL); - } - break; - case VALID: - enterOuterAlt(_localctx, 17); - { - setState(1402); - match(VALID); - setState(1403); - match(UNTIL); - setState(1404); - match(SINGLEQ_STRING_LITERAL); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_role_stmtContext extends ParserRuleContext { - public Role_nameContext role; - public Alter_role_optionsContext options; - public Name_Context name; - public Name_Context new_name; - public Name_Context database_name; - public IdentifierContext configuration_parameter; - public Param_valueContext value; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public List alter_role_options() { - return getRuleContexts(Alter_role_optionsContext.class); - } - public Alter_role_optionsContext alter_role_options(int i) { - return getRuleContext(Alter_role_optionsContext.class,i); - } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } - public List ALL() { return getTokens(PostgreSqlParser.ALL); } - public TerminalNode ALL(int i) { - return getToken(PostgreSqlParser.ALL, i); - } - public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } - public TerminalNode IN() { return getToken(PostgreSqlParser.IN, 0); } - public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } - public Param_valueContext param_value() { - return getRuleContext(Param_valueContext.class,0); - } - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public TerminalNode CURRENT() { return getToken(PostgreSqlParser.CURRENT, 0); } - public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } - public Alter_role_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_role_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_role_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_role_stmt(this); - } - } - - public final Alter_role_stmtContext alter_role_stmt() throws RecognitionException { - Alter_role_stmtContext _localctx = new Alter_role_stmtContext(_ctx, getState()); - enterRule(_localctx, 56, RULE_alter_role_stmt); - int _la; - try { - setState(1485); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1407); - match(ALTER); - setState(1408); - match(ROLE); - setState(1409); - ((Alter_role_stmtContext)_localctx).role = role_name(); - setState(1411); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(1410); - match(WITH); - } - } - - setState(1414); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(1413); - ((Alter_role_stmtContext)_localctx).options = alter_role_options(); - } - } - setState(1416); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==CONNECTION || _la==CREATEDB || _la==ENCRYPTED || _la==NOCREATEDB || _la==PASSWORD || ((((_la - 629)) & ~0x3f) == 0 && ((1L << (_la - 629)) & 1099243192321L) != 0) ); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1418); - match(ALTER); - setState(1419); - match(ROLE); - setState(1420); - ((Alter_role_stmtContext)_localctx).name = name_(); - setState(1421); - match(RENAME); - setState(1422); - match(TO); - setState(1423); - ((Alter_role_stmtContext)_localctx).new_name = name_(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1425); - match(ALTER); - setState(1426); - match(ROLE); - setState(1429); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURRENT_USER: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SESSION_USER: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1427); - ((Alter_role_stmtContext)_localctx).role = role_name(); - } - break; - case ALL: - { - setState(1428); - match(ALL); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1434); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN) { - { - setState(1431); - match(IN); - setState(1432); - match(DATABASE); - setState(1433); - ((Alter_role_stmtContext)_localctx).database_name = name_(); - } - } - - setState(1436); - match(SET); - setState(1437); - ((Alter_role_stmtContext)_localctx).configuration_parameter = identifier(0); - setState(1438); - _la = _input.LA(1); - if ( !(_la==TO || _la==EQUAL) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1441); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FALSE: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case ON: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case YES: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case COLON: - case NUMERIC_LITERAL: - case INTEGER_LITERAL: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - case QMARK: - { - setState(1439); - ((Alter_role_stmtContext)_localctx).value = param_value(); - } - break; - case DEFAULT: - { - setState(1440); - match(DEFAULT); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1443); - match(ALTER); - setState(1444); - match(ROLE); - setState(1447); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURRENT_USER: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SESSION_USER: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1445); - ((Alter_role_stmtContext)_localctx).role = role_name(); - } - break; - case ALL: - { - setState(1446); - match(ALL); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1452); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN) { - { - setState(1449); - match(IN); - setState(1450); - match(DATABASE); - setState(1451); - ((Alter_role_stmtContext)_localctx).database_name = name_(); - } - } - - setState(1454); - match(SET); - setState(1455); - ((Alter_role_stmtContext)_localctx).configuration_parameter = identifier(0); - setState(1456); - match(FROM); - setState(1457); - match(CURRENT); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1459); - match(ALTER); - setState(1460); - match(ROLE); - setState(1463); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURRENT_USER: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SESSION_USER: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1461); - ((Alter_role_stmtContext)_localctx).role = role_name(); - } - break; - case ALL: - { - setState(1462); - match(ALL); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1468); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN) { - { - setState(1465); - match(IN); - setState(1466); - match(DATABASE); - setState(1467); - ((Alter_role_stmtContext)_localctx).database_name = name_(); - } - } - - setState(1470); - match(RESET); - setState(1471); - ((Alter_role_stmtContext)_localctx).configuration_parameter = identifier(0); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1472); - match(ALTER); - setState(1473); - match(ROLE); - setState(1476); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURRENT_USER: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SESSION_USER: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1474); - ((Alter_role_stmtContext)_localctx).role = role_name(); - } - break; - case ALL: - { - setState(1475); - match(ALL); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1481); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN) { - { - setState(1478); - match(IN); - setState(1479); - match(DATABASE); - setState(1480); - ((Alter_role_stmtContext)_localctx).database_name = name_(); - } - } - - setState(1483); - match(RESET); - setState(1484); - match(ALL); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_rule_stmtContext extends ParserRuleContext { - public Name_Context name; - public IdentifierContext table_name; - public Name_Context new_name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Alter_rule_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_rule_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_rule_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_rule_stmt(this); - } - } - - public final Alter_rule_stmtContext alter_rule_stmt() throws RecognitionException { - Alter_rule_stmtContext _localctx = new Alter_rule_stmtContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_alter_rule_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1487); - match(ALTER); - setState(1488); - match(RULE); - setState(1489); - ((Alter_rule_stmtContext)_localctx).name = name_(); - setState(1490); - match(ON); - setState(1491); - ((Alter_rule_stmtContext)_localctx).table_name = identifier(0); - setState(1492); - match(RENAME); - setState(1493); - match(TO); - setState(1494); - ((Alter_rule_stmtContext)_localctx).new_name = name_(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_schema_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_name; - public IdentifierContext new_owner; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public Alter_schema_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_schema_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_schema_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_schema_stmt(this); - } - } - - public final Alter_schema_stmtContext alter_schema_stmt() throws RecognitionException { - Alter_schema_stmtContext _localctx = new Alter_schema_stmtContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_alter_schema_stmt); - try { - setState(1513); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1496); - match(ALTER); - setState(1497); - match(SCHEMA); - setState(1498); - ((Alter_schema_stmtContext)_localctx).name = identifier(0); - setState(1499); - match(RENAME); - setState(1500); - match(TO); - setState(1501); - ((Alter_schema_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1503); - match(ALTER); - setState(1504); - match(SCHEMA); - setState(1505); - ((Alter_schema_stmtContext)_localctx).name = identifier(0); - setState(1506); - match(OWNER); - setState(1507); - match(TO); - setState(1511); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1508); - ((Alter_schema_stmtContext)_localctx).new_owner = identifier(0); - } - break; - case CURRENT_USER: - { - setState(1509); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(1510); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_sequence_stmtContext extends ParserRuleContext { - public Name_Context name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Alter_sequence_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_sequence_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_sequence_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_sequence_stmt(this); - } - } - - public final Alter_sequence_stmtContext alter_sequence_stmt() throws RecognitionException { - Alter_sequence_stmtContext _localctx = new Alter_sequence_stmtContext(_ctx, getState()); - enterRule(_localctx, 62, RULE_alter_sequence_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1515); - match(ALTER); - setState(1516); - match(SEQUENCE); - setState(1519); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1517); - match(IF); - setState(1518); - match(EXISTS); - } - } - - setState(1521); - ((Alter_sequence_stmtContext)_localctx).name = name_(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_server_options_listContext extends ParserRuleContext { - public IdentifierContext option; - public Param_valueContext value; - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public List ADD() { return getTokens(PostgreSqlParser.ADD); } - public TerminalNode ADD(int i) { - return getToken(PostgreSqlParser.ADD, i); - } - public List SET() { return getTokens(PostgreSqlParser.SET); } - public TerminalNode SET(int i) { - return getToken(PostgreSqlParser.SET, i); - } - public List DROP() { return getTokens(PostgreSqlParser.DROP); } - public TerminalNode DROP(int i) { - return getToken(PostgreSqlParser.DROP, i); - } - public List param_value() { - return getRuleContexts(Param_valueContext.class); - } - public Param_valueContext param_value(int i) { - return getRuleContext(Param_valueContext.class,i); - } - public Alter_server_options_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_server_options_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_server_options_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_server_options_list(this); - } - } - - public final Alter_server_options_listContext alter_server_options_list() throws RecognitionException { - Alter_server_options_listContext _localctx = new Alter_server_options_listContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_alter_server_options_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - { - setState(1524); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { - case 1: - { - setState(1523); - _la = _input.LA(1); - if ( !(_la==ADD || _la==DROP || _la==SET) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(1526); - ((Alter_server_options_listContext)_localctx).option = identifier(0); - setState(1528); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245452583049L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -2918355150198407171L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3120954820635131899L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710895L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3341677518431191039L) != 0) || _la==QMARK) { - { - setState(1527); - ((Alter_server_options_listContext)_localctx).value = param_value(); - } - } - - } - setState(1540); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1530); - match(COMMA); - setState(1532); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) { - case 1: - { - setState(1531); - _la = _input.LA(1); - if ( !(_la==ADD || _la==DROP || _la==SET) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(1534); - ((Alter_server_options_listContext)_localctx).option = identifier(0); - setState(1536); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245452583049L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -2918355150198407171L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3120954820635131899L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710895L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3341677518431191039L) != 0) || _la==QMARK) { - { - setState(1535); - ((Alter_server_options_listContext)_localctx).value = param_value(); - } - } - - } - } - setState(1542); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_server_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public Role_nameContext new_owner; - public Name_Context new_name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode VERSION() { return getToken(PostgreSqlParser.VERSION, 0); } - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Alter_server_options_listContext alter_server_options_list() { - return getRuleContext(Alter_server_options_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public Alter_server_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_server_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_server_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_server_stmt(this); - } - } - - public final Alter_server_stmtContext alter_server_stmt() throws RecognitionException { - Alter_server_stmtContext _localctx = new Alter_server_stmtContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_alter_server_stmt); - int _la; - try { - setState(1573); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1543); - match(ALTER); - setState(1544); - match(SERVER); - setState(1545); - ((Alter_server_stmtContext)_localctx).name = identifier(0); - setState(1557); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { - case 1: - { - { - setState(1546); - match(VERSION); - setState(1547); - match(SINGLEQ_STRING_LITERAL); - } - } - break; - case 2: - { - { - setState(1550); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==VERSION) { - { - setState(1548); - match(VERSION); - setState(1549); - match(SINGLEQ_STRING_LITERAL); - } - } - - { - setState(1552); - match(OPTIONS); - setState(1553); - match(OPEN_PAREN); - setState(1554); - alter_server_options_list(); - setState(1555); - match(CLOSE_PAREN); - } - } - } - break; - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1559); - match(ALTER); - setState(1560); - match(SERVER); - setState(1561); - ((Alter_server_stmtContext)_localctx).name = identifier(0); - setState(1562); - match(OWNER); - setState(1563); - match(TO); - setState(1564); - ((Alter_server_stmtContext)_localctx).new_owner = role_name(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1566); - match(ALTER); - setState(1567); - match(SERVER); - setState(1568); - ((Alter_server_stmtContext)_localctx).name = identifier(0); - setState(1569); - match(RENAME); - setState(1570); - match(TO); - setState(1571); - ((Alter_server_stmtContext)_localctx).new_name = name_(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_statistics_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_owner; - public IdentifierContext new_name; - public IdentifierContext new_schema; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_statistics_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_statistics_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_statistics_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_statistics_stmt(this); - } - } - - public final Alter_statistics_stmtContext alter_statistics_stmt() throws RecognitionException { - Alter_statistics_stmtContext _localctx = new Alter_statistics_stmtContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_alter_statistics_stmt); - try { - setState(1599); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1575); - match(ALTER); - setState(1576); - match(STATISTICS); - setState(1577); - ((Alter_statistics_stmtContext)_localctx).name = identifier(0); - setState(1578); - match(OWNER); - setState(1579); - match(TO); - setState(1583); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1580); - ((Alter_statistics_stmtContext)_localctx).new_owner = identifier(0); - } - break; - case CURRENT_USER: - { - setState(1581); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(1582); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1585); - match(ALTER); - setState(1586); - match(STATISTICS); - setState(1587); - ((Alter_statistics_stmtContext)_localctx).name = identifier(0); - setState(1588); - match(RENAME); - setState(1589); - match(TO); - setState(1590); - ((Alter_statistics_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1592); - match(ALTER); - setState(1593); - match(STATISTICS); - setState(1594); - ((Alter_statistics_stmtContext)_localctx).name = identifier(0); - setState(1595); - match(SET); - setState(1596); - match(SCHEMA); - setState(1597); - ((Alter_statistics_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_subscription_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public Param_valueContext conninfo; - public Name_listContext publication_name; - public Role_nameContext new_owner; - public IdentifierContext new_name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } - public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public Param_valueContext param_value() { - return getRuleContext(Param_valueContext.class,0); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Option_listContext option_list() { - return getRuleContext(Option_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode REFRESH() { return getToken(PostgreSqlParser.REFRESH, 0); } - public TerminalNode ENABLE() { return getToken(PostgreSqlParser.ENABLE, 0); } - public TerminalNode DISABLE() { return getToken(PostgreSqlParser.DISABLE, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public Alter_subscription_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_subscription_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_subscription_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_subscription_stmt(this); - } - } - - public final Alter_subscription_stmtContext alter_subscription_stmt() throws RecognitionException { - Alter_subscription_stmtContext _localctx = new Alter_subscription_stmtContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_alter_subscription_stmt); - int _la; - try { - setState(1664); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1601); - match(ALTER); - setState(1602); - match(SUBSCRIPTION); - setState(1603); - ((Alter_subscription_stmtContext)_localctx).name = identifier(0); - setState(1604); - match(CONNECTION); - setState(1605); - ((Alter_subscription_stmtContext)_localctx).conninfo = param_value(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1607); - match(ALTER); - setState(1608); - match(SUBSCRIPTION); - setState(1609); - ((Alter_subscription_stmtContext)_localctx).name = identifier(0); - setState(1610); - match(SET); - setState(1611); - match(PUBLICATION); - setState(1612); - ((Alter_subscription_stmtContext)_localctx).publication_name = name_list(); - setState(1618); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(1613); - match(WITH); - setState(1614); - match(OPEN_PAREN); - setState(1615); - option_list(); - setState(1616); - match(CLOSE_PAREN); - } - } - - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1620); - match(ALTER); - setState(1621); - match(SUBSCRIPTION); - setState(1622); - ((Alter_subscription_stmtContext)_localctx).name = identifier(0); - setState(1623); - match(REFRESH); - setState(1624); - match(PUBLICATION); - setState(1630); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(1625); - match(WITH); - setState(1626); - match(OPEN_PAREN); - setState(1627); - option_list(); - setState(1628); - match(CLOSE_PAREN); - } - } - - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1632); - match(ALTER); - setState(1633); - match(SUBSCRIPTION); - setState(1634); - ((Alter_subscription_stmtContext)_localctx).name = identifier(0); - setState(1635); - match(ENABLE); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1637); - match(ALTER); - setState(1638); - match(SUBSCRIPTION); - setState(1639); - ((Alter_subscription_stmtContext)_localctx).name = identifier(0); - setState(1640); - match(DISABLE); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { setState(1642); - match(ALTER); + altereventtrigstmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { setState(1643); - match(SUBSCRIPTION); + altercollationstmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { setState(1644); - ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + alterdatabasestmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { setState(1645); - match(SET); + alterdatabasesetstmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { setState(1646); - match(OPEN_PAREN); + alterdefaultprivilegesstmt(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { setState(1647); - option_list(); - setState(1648); - match(CLOSE_PAREN); + alterdomainstmt(); } break; case 7: enterOuterAlt(_localctx, 7); { + setState(1648); + alterenumstmt(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1649); + alterextensionstmt(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { setState(1650); - match(ALTER); - setState(1651); - match(SUBSCRIPTION); - setState(1652); - ((Alter_subscription_stmtContext)_localctx).name = identifier(0); - setState(1653); - match(OWNER); - setState(1654); - match(TO); - setState(1655); - ((Alter_subscription_stmtContext)_localctx).new_owner = role_name(); + alterextensioncontentsstmt(); } break; - case 8: - enterOuterAlt(_localctx, 8); + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1651); + alterfdwstmt(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1652); + alterforeignserverstmt(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(1653); + alterfunctionstmt(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(1654); + altergroupstmt(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(1655); + alterobjectdependsstmt(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(1656); + alterobjectschemastmt(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); { setState(1657); - match(ALTER); - setState(1658); - match(SUBSCRIPTION); - setState(1659); - ((Alter_subscription_stmtContext)_localctx).name = identifier(0); - setState(1660); - match(RENAME); - setState(1661); - match(TO); - setState(1662); - ((Alter_subscription_stmtContext)_localctx).new_name = identifier(0); + alterownerstmt(); } break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_system_stmtContext extends ParserRuleContext { - public Token param; - public Param_valueContext value; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode SYSTEM() { return getToken(PostgreSqlParser.SYSTEM, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode IDENTIFIER() { return getToken(PostgreSqlParser.IDENTIFIER, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } - public Param_valueContext param_value() { - return getRuleContext(Param_valueContext.class,0); - } - public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public Alter_system_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_system_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_system_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_system_stmt(this); - } - } - - public final Alter_system_stmtContext alter_system_stmt() throws RecognitionException { - Alter_system_stmtContext _localctx = new Alter_system_stmtContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_alter_system_stmt); - int _la; - try { - setState(1680); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); + case 17: + enterOuterAlt(_localctx, 17); + { + setState(1658); + alteroperatorstmt(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(1659); + altertypestmt(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(1660); + alterpolicystmt(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(1661); + alterseqstmt(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(1662); + altersystemstmt(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(1663); + altertablestmt(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(1664); + altertblspcstmt(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(1665); + altercompositetypestmt(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); { setState(1666); - match(ALTER); - setState(1667); - match(SYSTEM); - setState(1668); - match(SET); - setState(1669); - ((Alter_system_stmtContext)_localctx).param = match(IDENTIFIER); - setState(1670); - _la = _input.LA(1); - if ( !(_la==TO || _la==EQUAL) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1671); - ((Alter_system_stmtContext)_localctx).value = param_value(); + alterpublicationstmt(); } break; - case 2: - enterOuterAlt(_localctx, 2); + case 26: + enterOuterAlt(_localctx, 26); + { + setState(1667); + alterrolesetstmt(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(1668); + alterrolestmt(); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(1669); + altersubscriptionstmt(); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(1670); + alterstatsstmt(); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(1671); + altertsconfigurationstmt(); + } + break; + case 31: + enterOuterAlt(_localctx, 31); { setState(1672); - match(ALTER); - setState(1673); - match(SYSTEM); - setState(1674); - match(RESET); - setState(1675); - ((Alter_system_stmtContext)_localctx).param = match(IDENTIFIER); + altertsdictionarystmt(); } break; - case 3: - enterOuterAlt(_localctx, 3); + case 32: + enterOuterAlt(_localctx, 32); + { + setState(1673); + alterusermappingstmt(); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(1674); + analyzestmt(); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(1675); + callstmt(); + } + break; + case 35: + enterOuterAlt(_localctx, 35); { setState(1676); - match(ALTER); + checkpointstmt(); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { setState(1677); - match(SYSTEM); + closeportalstmt(); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { setState(1678); - match(RESET); + clusterstmt(); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { setState(1679); - match(ALL); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_table_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_table_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_table_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_table_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_table_stmt(this); - } - } - - public final Alter_table_stmtContext alter_table_stmt() throws RecognitionException { - Alter_table_stmtContext _localctx = new Alter_table_stmtContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_alter_table_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1682); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_tablespace_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_name; - public IdentifierContext new_owner; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Option_listContext option_list() { - return getRuleContext(Option_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public Alter_tablespace_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_tablespace_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_tablespace_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_tablespace_stmt(this); - } - } - - public final Alter_tablespace_stmtContext alter_tablespace_stmt() throws RecognitionException { - Alter_tablespace_stmtContext _localctx = new Alter_tablespace_stmtContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_alter_tablespace_stmt); - try { - setState(1717); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1684); - match(ALTER); - setState(1685); - match(TABLESPACE); - setState(1686); - ((Alter_tablespace_stmtContext)_localctx).name = identifier(0); - setState(1687); - match(RENAME); - setState(1688); - match(TO); - setState(1689); - ((Alter_tablespace_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1691); - match(ALTER); - setState(1692); - match(TABLESPACE); - setState(1693); - ((Alter_tablespace_stmtContext)_localctx).name = identifier(0); - setState(1694); - match(OWNER); - setState(1695); - match(TO); - setState(1699); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(1696); - ((Alter_tablespace_stmtContext)_localctx).new_owner = identifier(0); - } - break; - case CURRENT_USER: - { - setState(1697); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(1698); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1701); - match(ALTER); - setState(1702); - match(TABLESPACE); - setState(1703); - ((Alter_tablespace_stmtContext)_localctx).name = identifier(0); - setState(1704); - match(SET); - setState(1705); - match(OPEN_PAREN); - setState(1706); - option_list(); - setState(1707); - match(CLOSE_PAREN); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1709); - match(ALTER); - setState(1710); - match(TABLESPACE); - setState(1711); - ((Alter_tablespace_stmtContext)_localctx).name = identifier(0); - setState(1712); - match(RESET); - setState(1713); - match(OPEN_PAREN); - setState(1714); - identifier_list(); - setState(1715); - match(CLOSE_PAREN); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_text_search_config_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public Identifier_listContext token_types; - public Identifier_listContext dictionary_names; - public IdentifierContext old_dictionary; - public IdentifierContext new_dictionary; - public IdentifierContext new_name; - public Role_nameContext new_owner; - public IdentifierContext new_schema; - public List ALTER() { return getTokens(PostgreSqlParser.ALTER); } - public TerminalNode ALTER(int i) { - return getToken(PostgreSqlParser.ALTER, i); - } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } - public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } - public TerminalNode ADD() { return getToken(PostgreSqlParser.ADD, 0); } - public TerminalNode MAPPING() { return getToken(PostgreSqlParser.MAPPING, 0); } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List identifier_list() { - return getRuleContexts(Identifier_listContext.class); - } - public Identifier_listContext identifier_list(int i) { - return getRuleContext(Identifier_listContext.class,i); - } - public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_text_search_config_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_text_search_config_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_text_search_config_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_text_search_config_stmt(this); - } - } - - public final Alter_text_search_config_stmtContext alter_text_search_config_stmt() throws RecognitionException { - Alter_text_search_config_stmtContext _localctx = new Alter_text_search_config_stmtContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_alter_text_search_config_stmt); - int _la; - try { - setState(1810); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1719); - match(ALTER); - setState(1720); - match(TEXT); - setState(1721); - match(SEARCH); - setState(1722); - match(CONFIGURATION); - setState(1723); - ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(1724); - match(ADD); - setState(1725); - match(MAPPING); - setState(1726); - match(FOR); - setState(1727); - ((Alter_text_search_config_stmtContext)_localctx).token_types = identifier_list(); - setState(1728); - match(WITH); - setState(1729); - ((Alter_text_search_config_stmtContext)_localctx).dictionary_names = identifier_list(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1731); - match(ALTER); - setState(1732); - match(TEXT); - setState(1733); - match(SEARCH); - setState(1734); - match(CONFIGURATION); - setState(1735); - ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(1736); - match(ALTER); - setState(1737); - match(MAPPING); - setState(1738); - match(FOR); - setState(1739); - ((Alter_text_search_config_stmtContext)_localctx).token_types = identifier_list(); - setState(1740); - match(WITH); - setState(1741); - ((Alter_text_search_config_stmtContext)_localctx).dictionary_names = identifier_list(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1743); - match(ALTER); - setState(1744); - match(TEXT); - setState(1745); - match(SEARCH); - setState(1746); - match(CONFIGURATION); - setState(1747); - ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(1748); - match(ALTER); - setState(1749); - match(MAPPING); - setState(1750); - match(REPLACE); - setState(1751); - ((Alter_text_search_config_stmtContext)_localctx).old_dictionary = identifier(0); - setState(1752); - match(WITH); - setState(1753); - ((Alter_text_search_config_stmtContext)_localctx).new_dictionary = identifier(0); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1755); - match(ALTER); - setState(1756); - match(TEXT); - setState(1757); - match(SEARCH); - setState(1758); - match(CONFIGURATION); - setState(1759); - ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(1760); - match(ALTER); - setState(1761); - match(MAPPING); - setState(1762); - match(FOR); - setState(1763); - ((Alter_text_search_config_stmtContext)_localctx).token_types = identifier_list(); - setState(1764); - match(REPLACE); - setState(1765); - ((Alter_text_search_config_stmtContext)_localctx).old_dictionary = identifier(0); - setState(1766); - match(WITH); - setState(1767); - ((Alter_text_search_config_stmtContext)_localctx).new_dictionary = identifier(0); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1769); - match(ALTER); - setState(1770); - match(TEXT); - setState(1771); - match(SEARCH); - setState(1772); - match(CONFIGURATION); - setState(1773); - ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(1774); - match(DROP); - setState(1775); - match(MAPPING); - setState(1778); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(1776); - match(IF); - setState(1777); - match(EXISTS); - } - } - - setState(1780); - match(FOR); - setState(1781); - ((Alter_text_search_config_stmtContext)_localctx).token_types = identifier_list(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1783); - match(ALTER); - setState(1784); - match(TEXT); - setState(1785); - match(SEARCH); - setState(1786); - match(CONFIGURATION); - setState(1787); - ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(1788); - match(RENAME); - setState(1789); - match(TO); - setState(1790); - ((Alter_text_search_config_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1792); - match(ALTER); - setState(1793); - match(TEXT); - setState(1794); - match(SEARCH); - setState(1795); - match(CONFIGURATION); - setState(1796); - ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(1797); - match(OWNER); - setState(1798); - match(TO); - setState(1799); - ((Alter_text_search_config_stmtContext)_localctx).new_owner = role_name(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(1801); - match(ALTER); - setState(1802); - match(TEXT); - setState(1803); - match(SEARCH); - setState(1804); - match(CONFIGURATION); - setState(1805); - ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(1806); - match(SET); - setState(1807); - match(SCHEMA); - setState(1808); - ((Alter_text_search_config_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_text_search_dict_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_text_search_dict_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_text_search_dict_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_text_search_dict_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_text_search_dict_stmt(this); - } - } - - public final Alter_text_search_dict_stmtContext alter_text_search_dict_stmt() throws RecognitionException { - Alter_text_search_dict_stmtContext _localctx = new Alter_text_search_dict_stmtContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_alter_text_search_dict_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1812); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_text_search_parser_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_text_search_parser_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_text_search_parser_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_text_search_parser_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_text_search_parser_stmt(this); - } - } - - public final Alter_text_search_parser_stmtContext alter_text_search_parser_stmt() throws RecognitionException { - Alter_text_search_parser_stmtContext _localctx = new Alter_text_search_parser_stmtContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_alter_text_search_parser_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1814); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_text_search_template_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext new_name; - public IdentifierContext new_schema; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } - public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Alter_text_search_template_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_text_search_template_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_text_search_template_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_text_search_template_stmt(this); - } - } - - public final Alter_text_search_template_stmtContext alter_text_search_template_stmt() throws RecognitionException { - Alter_text_search_template_stmtContext _localctx = new Alter_text_search_template_stmtContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_alter_text_search_template_stmt); - try { - setState(1834); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1816); - match(ALTER); - setState(1817); - match(TEXT); - setState(1818); - match(SEARCH); - setState(1819); - match(TEMPLATE); - setState(1820); - ((Alter_text_search_template_stmtContext)_localctx).name = identifier(0); - setState(1821); - match(RENAME); - setState(1822); - match(TO); - setState(1823); - ((Alter_text_search_template_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1825); - match(ALTER); - setState(1826); - match(TEXT); - setState(1827); - match(SEARCH); - setState(1828); - match(TEMPLATE); - setState(1829); - ((Alter_text_search_template_stmtContext)_localctx).name = identifier(0); - setState(1830); - match(SET); - setState(1831); - match(SCHEMA); - setState(1832); - ((Alter_text_search_template_stmtContext)_localctx).new_schema = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_trigger_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext table_name; - public IdentifierContext new_name; - public IdentifierContext extension_name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } - public List ON() { return getTokens(PostgreSqlParser.ON); } - public TerminalNode ON(int i) { - return getToken(PostgreSqlParser.ON, i); - } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode DEPENDS() { return getToken(PostgreSqlParser.DEPENDS, 0); } - public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } - public Alter_trigger_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_trigger_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_trigger_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_trigger_stmt(this); - } - } - - public final Alter_trigger_stmtContext alter_trigger_stmt() throws RecognitionException { - Alter_trigger_stmtContext _localctx = new Alter_trigger_stmtContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_alter_trigger_stmt); - try { - setState(1855); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1836); - match(ALTER); - setState(1837); - match(TRIGGER); - setState(1838); - ((Alter_trigger_stmtContext)_localctx).name = identifier(0); - setState(1839); - match(ON); - setState(1840); - ((Alter_trigger_stmtContext)_localctx).table_name = identifier(0); - setState(1841); - match(RENAME); - setState(1842); - match(TO); - setState(1843); - ((Alter_trigger_stmtContext)_localctx).new_name = identifier(0); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1845); - match(ALTER); - setState(1846); - match(TRIGGER); - setState(1847); - ((Alter_trigger_stmtContext)_localctx).name = identifier(0); - setState(1848); - match(ON); - setState(1849); - ((Alter_trigger_stmtContext)_localctx).table_name = identifier(0); - setState(1850); - match(DEPENDS); - setState(1851); - match(ON); - setState(1852); - match(EXTENSION); - setState(1853); - ((Alter_trigger_stmtContext)_localctx).extension_name = identifier(0); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_type_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_type_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_type_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_type_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_type_stmt(this); - } - } - - public final Alter_type_stmtContext alter_type_stmt() throws RecognitionException { - Alter_type_stmtContext _localctx = new Alter_type_stmtContext(_ctx, getState()); - enterRule(_localctx, 88, RULE_alter_type_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1857); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_user_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_user_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_user_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_user_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_user_stmt(this); - } - } - - public final Alter_user_stmtContext alter_user_stmt() throws RecognitionException { - Alter_user_stmtContext _localctx = new Alter_user_stmtContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_alter_user_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1859); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_user_mapping_stmtContext extends ParserRuleContext { - public Role_nameContext user; - public IdentifierContext server_name; - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } - public TerminalNode MAPPING() { return getToken(PostgreSqlParser.MAPPING, 0); } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } - public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Alter_server_options_listContext alter_server_options_list() { - return getRuleContext(Alter_server_options_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Alter_user_mapping_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_user_mapping_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_user_mapping_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_user_mapping_stmt(this); - } - } - - public final Alter_user_mapping_stmtContext alter_user_mapping_stmt() throws RecognitionException { - Alter_user_mapping_stmtContext _localctx = new Alter_user_mapping_stmtContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_alter_user_mapping_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1861); - match(ALTER); - setState(1862); - match(USER); - setState(1863); - match(MAPPING); - setState(1864); - match(FOR); - setState(1865); - ((Alter_user_mapping_stmtContext)_localctx).user = role_name(); - setState(1866); - match(SERVER); - setState(1867); - ((Alter_user_mapping_stmtContext)_localctx).server_name = identifier(0); - setState(1868); - match(OPTIONS); - { - setState(1869); - match(OPEN_PAREN); - setState(1870); - alter_server_options_list(); - setState(1871); - match(CLOSE_PAREN); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Alter_view_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Alter_view_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_alter_view_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_view_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_view_stmt(this); - } - } - - public final Alter_view_stmtContext alter_view_stmt() throws RecognitionException { - Alter_view_stmtContext _localctx = new Alter_view_stmtContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_alter_view_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1873); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Analyze_stmtContext extends ParserRuleContext { - public TerminalNode ANALYZE() { return getToken(PostgreSqlParser.ANALYZE, 0); } - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Analyze_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_analyze_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAnalyze_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAnalyze_stmt(this); - } - } - - public final Analyze_stmtContext analyze_stmt() throws RecognitionException { - Analyze_stmtContext _localctx = new Analyze_stmtContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_analyze_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1875); - match(ANALYZE); - setState(1877); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==VERBOSE) { - { - setState(1876); - match(VERBOSE); - } - } - - setState(1879); - table_name_(); - setState(1884); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(1880); - match(OPEN_PAREN); - setState(1881); - name_list(); - setState(1882); - match(CLOSE_PAREN); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Close_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Close_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_close_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterClose_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitClose_stmt(this); - } - } - - public final Close_stmtContext close_stmt() throws RecognitionException { - Close_stmtContext _localctx = new Close_stmtContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_close_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1886); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Cluster_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Cluster_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_cluster_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCluster_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCluster_stmt(this); - } - } - - public final Cluster_stmtContext cluster_stmt() throws RecognitionException { - Cluster_stmtContext _localctx = new Cluster_stmtContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_cluster_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1888); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Comment_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Comment_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_comment_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterComment_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitComment_stmt(this); - } - } - - public final Comment_stmtContext comment_stmt() throws RecognitionException { - Comment_stmtContext _localctx = new Comment_stmtContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_comment_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1890); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Commit_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Commit_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_commit_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCommit_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCommit_stmt(this); - } - } - - public final Commit_stmtContext commit_stmt() throws RecognitionException { - Commit_stmtContext _localctx = new Commit_stmtContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_commit_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1892); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Commit_prepared_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Commit_prepared_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_commit_prepared_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCommit_prepared_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCommit_prepared_stmt(this); - } - } - - public final Commit_prepared_stmtContext commit_prepared_stmt() throws RecognitionException { - Commit_prepared_stmtContext _localctx = new Commit_prepared_stmtContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_commit_prepared_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1894); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Copy_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Copy_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_copy_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_stmt(this); - } - } - - public final Copy_stmtContext copy_stmt() throws RecognitionException { - Copy_stmtContext _localctx = new Copy_stmtContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_copy_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1896); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_stmtContext extends ParserRuleContext { - public Create_access_method_stmtContext create_access_method_stmt() { - return getRuleContext(Create_access_method_stmtContext.class,0); - } - public Create_aggregate_stmtContext create_aggregate_stmt() { - return getRuleContext(Create_aggregate_stmtContext.class,0); - } - public Create_cast_stmtContext create_cast_stmt() { - return getRuleContext(Create_cast_stmtContext.class,0); - } - public Create_collation_stmtContext create_collation_stmt() { - return getRuleContext(Create_collation_stmtContext.class,0); - } - public Create_conversion_stmtContext create_conversion_stmt() { - return getRuleContext(Create_conversion_stmtContext.class,0); - } - public Create_database_stmtContext create_database_stmt() { - return getRuleContext(Create_database_stmtContext.class,0); - } - public Create_domain_stmtContext create_domain_stmt() { - return getRuleContext(Create_domain_stmtContext.class,0); - } - public Create_event_trigger_stmtContext create_event_trigger_stmt() { - return getRuleContext(Create_event_trigger_stmtContext.class,0); - } - public Create_foreign_data_stmtContext create_foreign_data_stmt() { - return getRuleContext(Create_foreign_data_stmtContext.class,0); - } - public Create_foreign_table_stmtContext create_foreign_table_stmt() { - return getRuleContext(Create_foreign_table_stmtContext.class,0); - } - public Create_function_stmtContext create_function_stmt() { - return getRuleContext(Create_function_stmtContext.class,0); - } - public Create_group_stmtContext create_group_stmt() { - return getRuleContext(Create_group_stmtContext.class,0); - } - public Create_index_stmtContext create_index_stmt() { - return getRuleContext(Create_index_stmtContext.class,0); - } - public Create_language_stmtContext create_language_stmt() { - return getRuleContext(Create_language_stmtContext.class,0); - } - public Create_materialized_view_stmtContext create_materialized_view_stmt() { - return getRuleContext(Create_materialized_view_stmtContext.class,0); - } - public Create_operator_stmtContext create_operator_stmt() { - return getRuleContext(Create_operator_stmtContext.class,0); - } - public Create_operator_class_stmtContext create_operator_class_stmt() { - return getRuleContext(Create_operator_class_stmtContext.class,0); - } - public Create_operator_family_stmtContext create_operator_family_stmt() { - return getRuleContext(Create_operator_family_stmtContext.class,0); - } - public Create_policy_stmtContext create_policy_stmt() { - return getRuleContext(Create_policy_stmtContext.class,0); - } - public Create_role_stmtContext create_role_stmt() { - return getRuleContext(Create_role_stmtContext.class,0); - } - public Create_rule_stmtContext create_rule_stmt() { - return getRuleContext(Create_rule_stmtContext.class,0); - } - public Create_schema_stmtContext create_schema_stmt() { - return getRuleContext(Create_schema_stmtContext.class,0); - } - public Create_sequence_stmtContext create_sequence_stmt() { - return getRuleContext(Create_sequence_stmtContext.class,0); - } - public Create_server_stmtContext create_server_stmt() { - return getRuleContext(Create_server_stmtContext.class,0); - } - public Create_statistics_stmtContext create_statistics_stmt() { - return getRuleContext(Create_statistics_stmtContext.class,0); - } - public Create_subscription_stmtContext create_subscription_stmt() { - return getRuleContext(Create_subscription_stmtContext.class,0); - } - public Create_table_stmtContext create_table_stmt() { - return getRuleContext(Create_table_stmtContext.class,0); - } - public Create_table_as_stmtContext create_table_as_stmt() { - return getRuleContext(Create_table_as_stmtContext.class,0); - } - public Create_tablespace_stmtContext create_tablespace_stmt() { - return getRuleContext(Create_tablespace_stmtContext.class,0); - } - public Create_text_search_config_stmtContext create_text_search_config_stmt() { - return getRuleContext(Create_text_search_config_stmtContext.class,0); - } - public Create_text_search_dict_stmtContext create_text_search_dict_stmt() { - return getRuleContext(Create_text_search_dict_stmtContext.class,0); - } - public Create_text_search_parser_stmtContext create_text_search_parser_stmt() { - return getRuleContext(Create_text_search_parser_stmtContext.class,0); - } - public Create_text_search_template_stmtContext create_text_search_template_stmt() { - return getRuleContext(Create_text_search_template_stmtContext.class,0); - } - public Create_transform_stmtContext create_transform_stmt() { - return getRuleContext(Create_transform_stmtContext.class,0); - } - public Create_trigger_stmtContext create_trigger_stmt() { - return getRuleContext(Create_trigger_stmtContext.class,0); - } - public Create_type_stmtContext create_type_stmt() { - return getRuleContext(Create_type_stmtContext.class,0); - } - public Create_user_stmtContext create_user_stmt() { - return getRuleContext(Create_user_stmtContext.class,0); - } - public Create_user_mapping_stmtContext create_user_mapping_stmt() { - return getRuleContext(Create_user_mapping_stmtContext.class,0); - } - public Create_view_stmtContext create_view_stmt() { - return getRuleContext(Create_view_stmtContext.class,0); - } - public Create_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_stmt(this); - } - } - - public final Create_stmtContext create_stmt() throws RecognitionException { - Create_stmtContext _localctx = new Create_stmtContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_create_stmt); - try { - setState(1937); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1898); - create_access_method_stmt(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1899); - create_aggregate_stmt(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1900); - create_cast_stmt(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1901); - create_collation_stmt(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1902); - create_conversion_stmt(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1903); - create_database_stmt(); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1904); - create_domain_stmt(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(1905); - create_event_trigger_stmt(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(1906); - create_foreign_data_stmt(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(1907); - create_foreign_table_stmt(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(1908); - create_function_stmt(); - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(1909); - create_group_stmt(); - } - break; - case 13: - enterOuterAlt(_localctx, 13); - { - setState(1910); - create_index_stmt(); - } - break; - case 14: - enterOuterAlt(_localctx, 14); - { - setState(1911); - create_language_stmt(); - } - break; - case 15: - enterOuterAlt(_localctx, 15); - { - setState(1912); - create_materialized_view_stmt(); - } - break; - case 16: - enterOuterAlt(_localctx, 16); - { - setState(1913); - create_operator_stmt(); - } - break; - case 17: - enterOuterAlt(_localctx, 17); - { - setState(1914); - create_operator_class_stmt(); - } - break; - case 18: - enterOuterAlt(_localctx, 18); - { - setState(1915); - create_operator_family_stmt(); - } - break; - case 19: - enterOuterAlt(_localctx, 19); - { - setState(1916); - create_policy_stmt(); - } - break; - case 20: - enterOuterAlt(_localctx, 20); - { - setState(1917); - create_role_stmt(); - } - break; - case 21: - enterOuterAlt(_localctx, 21); - { - setState(1918); - create_rule_stmt(); - } - break; - case 22: - enterOuterAlt(_localctx, 22); - { - setState(1919); - create_schema_stmt(); - } - break; - case 23: - enterOuterAlt(_localctx, 23); - { - setState(1920); - create_sequence_stmt(); - } - break; - case 24: - enterOuterAlt(_localctx, 24); - { - setState(1921); - create_server_stmt(); - } - break; - case 25: - enterOuterAlt(_localctx, 25); - { - setState(1922); - create_statistics_stmt(); - } - break; - case 26: - enterOuterAlt(_localctx, 26); - { - setState(1923); - create_subscription_stmt(); - } - break; - case 27: - enterOuterAlt(_localctx, 27); - { - setState(1924); - create_table_stmt(); - } - break; - case 28: - enterOuterAlt(_localctx, 28); - { - setState(1925); - create_table_as_stmt(); - } - break; - case 29: - enterOuterAlt(_localctx, 29); - { - setState(1926); - create_tablespace_stmt(); - } - break; - case 30: - enterOuterAlt(_localctx, 30); - { - setState(1927); - create_text_search_config_stmt(); - } - break; - case 31: - enterOuterAlt(_localctx, 31); - { - setState(1928); - create_text_search_dict_stmt(); - } - break; - case 32: - enterOuterAlt(_localctx, 32); - { - setState(1929); - create_text_search_parser_stmt(); - } - break; - case 33: - enterOuterAlt(_localctx, 33); - { - setState(1930); - create_text_search_template_stmt(); - } - break; - case 34: - enterOuterAlt(_localctx, 34); - { - setState(1931); - create_transform_stmt(); - } - break; - case 35: - enterOuterAlt(_localctx, 35); - { - setState(1932); - create_trigger_stmt(); - } - break; - case 36: - enterOuterAlt(_localctx, 36); - { - setState(1933); - create_type_stmt(); - } - break; - case 37: - enterOuterAlt(_localctx, 37); - { - setState(1934); - create_user_stmt(); - } - break; - case 38: - enterOuterAlt(_localctx, 38); - { - setState(1935); - create_user_mapping_stmt(); + commentstmt(); } break; case 39: enterOuterAlt(_localctx, 39); { - setState(1936); - create_view_stmt(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_access_method_stmtContext extends ParserRuleContext { - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode ACCESS() { return getToken(PostgreSqlParser.ACCESS, 0); } - public TerminalNode METHOD() { return getToken(PostgreSqlParser.METHOD, 0); } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public TerminalNode TYPE() { return getToken(PostgreSqlParser.TYPE, 0); } - public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } - public TerminalNode HANDLER() { return getToken(PostgreSqlParser.HANDLER, 0); } - public Create_access_method_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_access_method_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_access_method_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_access_method_stmt(this); - } - } - - public final Create_access_method_stmtContext create_access_method_stmt() throws RecognitionException { - Create_access_method_stmtContext _localctx = new Create_access_method_stmtContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_create_access_method_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(1939); - match(CREATE); - setState(1940); - match(ACCESS); - setState(1941); - match(METHOD); - setState(1942); - name_(); - setState(1943); - match(TYPE); - setState(1944); - match(INDEX); - setState(1945); - match(HANDLER); - setState(1946); - name_(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_aggregate_stmtContext extends ParserRuleContext { - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List data_type_list() { - return getRuleContexts(Data_type_listContext.class); - } - public Data_type_listContext data_type_list(int i) { - return getRuleContext(Data_type_listContext.class,i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public TerminalNode SFUNC() { return getToken(PostgreSqlParser.SFUNC, 0); } - public List EQUAL() { return getTokens(PostgreSqlParser.EQUAL); } - public TerminalNode EQUAL(int i) { - return getToken(PostgreSqlParser.EQUAL, i); - } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public TerminalNode STYPE() { return getToken(PostgreSqlParser.STYPE, 0); } - public TerminalNode SSPACE() { return getToken(PostgreSqlParser.SSPACE, 0); } - public List INTEGER_LITERAL() { return getTokens(PostgreSqlParser.INTEGER_LITERAL); } - public TerminalNode INTEGER_LITERAL(int i) { - return getToken(PostgreSqlParser.INTEGER_LITERAL, i); - } - public TerminalNode FINALFUNC() { return getToken(PostgreSqlParser.FINALFUNC, 0); } - public TerminalNode FINALFUNC_EXTRA() { return getToken(PostgreSqlParser.FINALFUNC_EXTRA, 0); } - public TerminalNode COMBINEFUNC() { return getToken(PostgreSqlParser.COMBINEFUNC, 0); } - public TerminalNode SERIALFUNC() { return getToken(PostgreSqlParser.SERIALFUNC, 0); } - public TerminalNode DESERIALFUNC() { return getToken(PostgreSqlParser.DESERIALFUNC, 0); } - public TerminalNode INITCOND() { return getToken(PostgreSqlParser.INITCOND, 0); } - public ExprContext expr() { - return getRuleContext(ExprContext.class,0); - } - public TerminalNode MSFUNC() { return getToken(PostgreSqlParser.MSFUNC, 0); } - public TerminalNode MINVFUNC() { return getToken(PostgreSqlParser.MINVFUNC, 0); } - public TerminalNode MSTYPE() { return getToken(PostgreSqlParser.MSTYPE, 0); } - public TerminalNode MSSPACE() { return getToken(PostgreSqlParser.MSSPACE, 0); } - public TerminalNode MFINALFUNC() { return getToken(PostgreSqlParser.MFINALFUNC, 0); } - public TerminalNode MFINALFUNC_EXTRA() { return getToken(PostgreSqlParser.MFINALFUNC_EXTRA, 0); } - public TerminalNode MINITCOND() { return getToken(PostgreSqlParser.MINITCOND, 0); } - public TerminalNode SORTOP() { return getToken(PostgreSqlParser.SORTOP, 0); } - public TerminalNode PARALLEL() { return getToken(PostgreSqlParser.PARALLEL, 0); } - public List IN() { return getTokens(PostgreSqlParser.IN); } - public TerminalNode IN(int i) { - return getToken(PostgreSqlParser.IN, i); - } - public List VARIADIC() { return getTokens(PostgreSqlParser.VARIADIC); } - public TerminalNode VARIADIC(int i) { - return getToken(PostgreSqlParser.VARIADIC, i); - } - public TerminalNode SAFE() { return getToken(PostgreSqlParser.SAFE, 0); } - public TerminalNode RESTRICTED() { return getToken(PostgreSqlParser.RESTRICTED, 0); } - public TerminalNode UNSAFE() { return getToken(PostgreSqlParser.UNSAFE, 0); } - public TerminalNode ORDER() { return getToken(PostgreSqlParser.ORDER, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public TerminalNode HYPOTHETICAL() { return getToken(PostgreSqlParser.HYPOTHETICAL, 0); } - public TerminalNode BASETYPE() { return getToken(PostgreSqlParser.BASETYPE, 0); } - public Data_typeContext data_type() { - return getRuleContext(Data_typeContext.class,0); - } - public Create_aggregate_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_aggregate_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_aggregate_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_aggregate_stmt(this); - } - } - - public final Create_aggregate_stmtContext create_aggregate_stmt() throws RecognitionException { - Create_aggregate_stmtContext _localctx = new Create_aggregate_stmtContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_create_aggregate_stmt); - int _la; - try { - setState(2230); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - { - setState(1948); - match(CREATE); - setState(1949); - match(AGGREGATE); - setState(1950); - name_(); - setState(1951); - match(OPEN_PAREN); - setState(1953); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN || _la==VARIADIC) { - { - setState(1952); - _la = _input.LA(1); - if ( !(_la==IN || _la==VARIADIC) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(1956); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) { - case 1: - { - setState(1955); - name_(); - } - break; - } - setState(1958); - data_type_list(); - setState(1959); - match(CLOSE_PAREN); - setState(1960); - match(OPEN_PAREN); - setState(1961); - match(SFUNC); - setState(1962); - match(EQUAL); - setState(1963); - identifier(0); - setState(1964); - match(COMMA); - setState(1965); - match(STYPE); - setState(1966); - match(EQUAL); - setState(1967); - identifier(0); - setState(1972); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { - case 1: - { - setState(1968); - match(COMMA); - setState(1969); - match(SSPACE); - setState(1970); - match(EQUAL); - setState(1971); - match(INTEGER_LITERAL); - } - break; - } - setState(1978); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) { - case 1: - { - setState(1974); - match(COMMA); - setState(1975); - match(FINALFUNC); - setState(1976); - match(EQUAL); - setState(1977); - identifier(0); - } - break; - } - setState(1982); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) { - case 1: - { - setState(1980); - match(COMMA); - setState(1981); - match(FINALFUNC_EXTRA); - } - break; - } - setState(1988); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { - case 1: - { - setState(1984); - match(COMMA); - setState(1985); - match(COMBINEFUNC); - setState(1986); - match(EQUAL); - setState(1987); - identifier(0); - } - break; - } - setState(1994); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { - case 1: - { - setState(1990); - match(COMMA); - setState(1991); - match(SERIALFUNC); - setState(1992); - match(EQUAL); - setState(1993); - identifier(0); - } - break; - } - setState(2000); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) { - case 1: - { - setState(1996); - match(COMMA); - setState(1997); - match(DESERIALFUNC); - setState(1998); - match(EQUAL); - setState(1999); - identifier(0); - } - break; - } - setState(2006); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { - case 1: - { - setState(2002); - match(COMMA); - setState(2003); - match(INITCOND); - setState(2004); - match(EQUAL); - setState(2005); - expr(0); - } - break; - } - setState(2012); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { - case 1: - { - setState(2008); - match(COMMA); - setState(2009); - match(MSFUNC); - setState(2010); - match(EQUAL); - setState(2011); - identifier(0); - } - break; - } - setState(2018); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { - case 1: - { - setState(2014); - match(COMMA); - setState(2015); - match(MINVFUNC); - setState(2016); - match(EQUAL); - setState(2017); - identifier(0); - } - break; - } - setState(2024); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { - case 1: - { - setState(2020); - match(COMMA); - setState(2021); - match(MSTYPE); - setState(2022); - match(EQUAL); - setState(2023); - identifier(0); - } - break; - } - setState(2030); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { - case 1: - { - setState(2026); - match(COMMA); - setState(2027); - match(MSSPACE); - setState(2028); - match(EQUAL); - setState(2029); - match(INTEGER_LITERAL); - } - break; - } - setState(2036); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { - case 1: - { - setState(2032); - match(COMMA); - setState(2033); - match(MFINALFUNC); - setState(2034); - match(EQUAL); - setState(2035); - identifier(0); - } - break; - } - setState(2040); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { - case 1: - { - setState(2038); - match(COMMA); - setState(2039); - match(MFINALFUNC_EXTRA); - } - break; - } - setState(2046); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { - case 1: - { - setState(2042); - match(COMMA); - setState(2043); - match(MINITCOND); - setState(2044); - match(EQUAL); - setState(2045); - identifier(0); - } - break; - } - setState(2052); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { - case 1: - { - setState(2048); - match(COMMA); - setState(2049); - match(SORTOP); - setState(2050); - match(EQUAL); - setState(2051); - identifier(0); - } - break; - } - setState(2058); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2054); - match(COMMA); - setState(2055); - match(PARALLEL); - setState(2056); - match(EQUAL); - setState(2057); - _la = _input.LA(1); - if ( !(((((_la - 688)) & ~0x3f) == 0 && ((1L << (_la - 688)) & 7L) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(2060); - match(CLOSE_PAREN); - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - { - setState(2062); - match(CREATE); - setState(2063); - match(AGGREGATE); - setState(2064); - name_(); - setState(2065); - match(OPEN_PAREN); - setState(2073); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245456777353L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513601L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206585526350118915L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3129962019889872891L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3314651522620456959L) != 0)) { - { - setState(2067); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN || _la==VARIADIC) { - { - setState(2066); - _la = _input.LA(1); - if ( !(_la==IN || _la==VARIADIC) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(2070); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { - case 1: - { - setState(2069); - name_(); - } - break; - } - setState(2072); - data_type_list(); - } - } - - setState(2075); - match(ORDER); - setState(2076); - match(BY); - setState(2078); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN || _la==VARIADIC) { - { - setState(2077); - _la = _input.LA(1); - if ( !(_la==IN || _la==VARIADIC) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(2081); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { - case 1: - { - setState(2080); - name_(); - } - break; - } - setState(2083); - data_type_list(); - setState(2084); - match(CLOSE_PAREN); - setState(2085); - match(OPEN_PAREN); - setState(2086); - match(SFUNC); - setState(2087); - match(EQUAL); - setState(2088); - identifier(0); - setState(2089); - match(COMMA); - setState(2090); - match(STYPE); - setState(2091); - match(EQUAL); - setState(2092); - identifier(0); - setState(2097); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { - case 1: - { - setState(2093); - match(COMMA); - setState(2094); - match(SSPACE); - setState(2095); - match(EQUAL); - setState(2096); - match(INTEGER_LITERAL); - } - break; - } - setState(2103); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { - case 1: - { - setState(2099); - match(COMMA); - setState(2100); - match(FINALFUNC); - setState(2101); - match(EQUAL); - setState(2102); - identifier(0); - } - break; - } - setState(2107); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { - case 1: - { - setState(2105); - match(COMMA); - setState(2106); - match(FINALFUNC_EXTRA); - } - break; - } - setState(2113); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { - case 1: - { - setState(2109); - match(COMMA); - setState(2110); - match(INITCOND); - setState(2111); - match(EQUAL); - setState(2112); - expr(0); - } - break; - } - setState(2119); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { - case 1: - { - setState(2115); - match(COMMA); - setState(2116); - match(PARALLEL); - setState(2117); - match(EQUAL); - setState(2118); - _la = _input.LA(1); - if ( !(((((_la - 688)) & ~0x3f) == 0 && ((1L << (_la - 688)) & 7L) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(2123); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2121); - match(COMMA); - setState(2122); - match(HYPOTHETICAL); - } - } - - setState(2125); - match(CLOSE_PAREN); - } - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - { - setState(2127); - match(CREATE); - setState(2128); - match(AGGREGATE); - setState(2129); - name_(); - setState(2130); - match(OPEN_PAREN); - setState(2131); - match(BASETYPE); - setState(2132); - match(EQUAL); - setState(2133); - data_type(); - setState(2134); - match(COMMA); - setState(2135); - match(SFUNC); - setState(2136); - match(EQUAL); - setState(2137); - identifier(0); - setState(2138); - match(COMMA); - setState(2139); - match(STYPE); - setState(2140); - match(EQUAL); - setState(2141); - identifier(0); - setState(2146); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { - case 1: - { - setState(2142); - match(COMMA); - setState(2143); - match(SSPACE); - setState(2144); - match(EQUAL); - setState(2145); - match(INTEGER_LITERAL); - } - break; - } - setState(2152); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { - case 1: - { - setState(2148); - match(COMMA); - setState(2149); - match(FINALFUNC); - setState(2150); - match(EQUAL); - setState(2151); - identifier(0); - } - break; - } - setState(2156); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) { - case 1: - { - setState(2154); - match(COMMA); - setState(2155); - match(FINALFUNC_EXTRA); - } - break; - } - setState(2162); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { - case 1: - { - setState(2158); - match(COMMA); - setState(2159); - match(COMBINEFUNC); - setState(2160); - match(EQUAL); - setState(2161); - identifier(0); - } - break; - } - setState(2168); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) { - case 1: - { - setState(2164); - match(COMMA); - setState(2165); - match(SERIALFUNC); - setState(2166); - match(EQUAL); - setState(2167); - identifier(0); - } - break; - } - setState(2174); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { - case 1: - { - setState(2170); - match(COMMA); - setState(2171); - match(DESERIALFUNC); - setState(2172); - match(EQUAL); - setState(2173); - identifier(0); - } - break; - } - setState(2180); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) { - case 1: - { - setState(2176); - match(COMMA); - setState(2177); - match(INITCOND); - setState(2178); - match(EQUAL); - setState(2179); - expr(0); - } - break; - } - setState(2186); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { - case 1: - { - setState(2182); - match(COMMA); - setState(2183); - match(MSFUNC); - setState(2184); - match(EQUAL); - setState(2185); - identifier(0); - } - break; - } - setState(2192); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) { - case 1: - { - setState(2188); - match(COMMA); - setState(2189); - match(MINVFUNC); - setState(2190); - match(EQUAL); - setState(2191); - identifier(0); - } - break; - } - setState(2198); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { - case 1: - { - setState(2194); - match(COMMA); - setState(2195); - match(MSTYPE); - setState(2196); - match(EQUAL); - setState(2197); - identifier(0); - } - break; - } - setState(2204); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) { - case 1: - { - setState(2200); - match(COMMA); - setState(2201); - match(MSSPACE); - setState(2202); - match(EQUAL); - setState(2203); - match(INTEGER_LITERAL); - } - break; - } - setState(2210); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { - case 1: - { - setState(2206); - match(COMMA); - setState(2207); - match(MFINALFUNC); - setState(2208); - match(EQUAL); - setState(2209); - identifier(0); - } - break; - } - setState(2214); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { - case 1: - { - setState(2212); - match(COMMA); - setState(2213); - match(MFINALFUNC_EXTRA); - } - break; - } - setState(2220); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { - case 1: - { - setState(2216); - match(COMMA); - setState(2217); - match(MINITCOND); - setState(2218); - match(EQUAL); - setState(2219); - identifier(0); - } - break; - } - setState(2226); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2222); - match(COMMA); - setState(2223); - match(SORTOP); - setState(2224); - match(EQUAL); - setState(2225); - identifier(0); - } - } - - setState(2228); - match(CLOSE_PAREN); - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_cast_stmtContext extends ParserRuleContext { - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List data_type() { - return getRuleContexts(Data_typeContext.class); - } - public Data_typeContext data_type(int i) { - return getRuleContext(Data_typeContext.class,i); - } - public List AS() { return getTokens(PostgreSqlParser.AS); } - public TerminalNode AS(int i) { - return getToken(PostgreSqlParser.AS, i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public TerminalNode ASSIGNMENT() { return getToken(PostgreSqlParser.ASSIGNMENT, 0); } - public TerminalNode IMPLICIT() { return getToken(PostgreSqlParser.IMPLICIT, 0); } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } - public TerminalNode INOUT() { return getToken(PostgreSqlParser.INOUT, 0); } - public Data_type_listContext data_type_list() { - return getRuleContext(Data_type_listContext.class,0); - } - public Create_cast_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_cast_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_cast_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_cast_stmt(this); - } - } - - public final Create_cast_stmtContext create_cast_stmt() throws RecognitionException { - Create_cast_stmtContext _localctx = new Create_cast_stmtContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_create_cast_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2232); - match(CREATE); - setState(2233); - match(CAST); - setState(2234); - match(OPEN_PAREN); - setState(2235); - data_type(); - setState(2236); - match(AS); - setState(2237); - data_type(); - setState(2238); - match(CLOSE_PAREN); - setState(2252); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { - case 1: - { - { - setState(2239); - match(WITH); - setState(2240); - match(FUNCTION); - setState(2241); - identifier(0); - setState(2246); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(2242); - match(OPEN_PAREN); - setState(2243); - data_type_list(); - setState(2244); - match(CLOSE_PAREN); - } - } - - } - } - break; - case 2: - { - { - setState(2248); - match(WITHOUT); - setState(2249); - match(FUNCTION); - } - } - break; - case 3: - { - { - setState(2250); - match(WITH); - setState(2251); - match(INOUT); - } - } - break; - } - setState(2258); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { - case 1: - { - setState(2254); - match(AS); - setState(2255); - match(ASSIGNMENT); - } - break; - case 2: - { - setState(2256); - match(AS); - setState(2257); - match(IMPLICIT); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_collation_optContext extends ParserRuleContext { - public TerminalNode LOCALE() { return getToken(PostgreSqlParser.LOCALE, 0); } - public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } - public ExprContext expr() { - return getRuleContext(ExprContext.class,0); - } - public TerminalNode LC_COLLATE() { return getToken(PostgreSqlParser.LC_COLLATE, 0); } - public TerminalNode LC_CTYPE() { return getToken(PostgreSqlParser.LC_CTYPE, 0); } - public TerminalNode PROVIDER() { return getToken(PostgreSqlParser.PROVIDER, 0); } - public TerminalNode VERSION() { return getToken(PostgreSqlParser.VERSION, 0); } - public TerminalNode DOUBLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.DOUBLEQ_STRING_LITERAL, 0); } - public Create_collation_optContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_collation_opt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_collation_opt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_collation_opt(this); - } - } - - public final Create_collation_optContext create_collation_opt() throws RecognitionException { - Create_collation_optContext _localctx = new Create_collation_optContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_create_collation_opt); - try { - setState(2278); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LOCALE: - enterOuterAlt(_localctx, 1); - { - setState(2260); - match(LOCALE); - setState(2261); - match(EQUAL); - setState(2262); - expr(0); - } - break; - case LC_COLLATE: - enterOuterAlt(_localctx, 2); - { - setState(2263); - match(LC_COLLATE); - setState(2264); - match(EQUAL); - setState(2265); - expr(0); - } - break; - case LC_CTYPE: - enterOuterAlt(_localctx, 3); - { - setState(2266); - match(LC_CTYPE); - setState(2267); - match(EQUAL); - setState(2268); - expr(0); - } - break; - case PROVIDER: - enterOuterAlt(_localctx, 4); - { - setState(2269); - match(PROVIDER); - setState(2270); - match(EQUAL); - setState(2271); - expr(0); - } - break; - case VERSION: - enterOuterAlt(_localctx, 5); - { - setState(2272); - match(VERSION); - setState(2273); - match(EQUAL); - setState(2274); - expr(0); - } - break; - case DOUBLEQ_STRING_LITERAL: - enterOuterAlt(_localctx, 6); - { - setState(2275); - match(DOUBLEQ_STRING_LITERAL); - setState(2276); - match(EQUAL); - setState(2277); - expr(0); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_collation_opt_listContext extends ParserRuleContext { - public List create_collation_opt() { - return getRuleContexts(Create_collation_optContext.class); - } - public Create_collation_optContext create_collation_opt(int i) { - return getRuleContext(Create_collation_optContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Create_collation_opt_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_collation_opt_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_collation_opt_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_collation_opt_list(this); - } - } - - public final Create_collation_opt_listContext create_collation_opt_list() throws RecognitionException { - Create_collation_opt_listContext _localctx = new Create_collation_opt_listContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_create_collation_opt_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2280); - create_collation_opt(); - setState(2285); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(2281); - match(COMMA); - setState(2282); - create_collation_opt(); - } - } - setState(2287); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_collation_stmtContext extends ParserRuleContext { - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Create_collation_opt_listContext create_collation_opt_list() { - return getRuleContext(Create_collation_opt_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public Create_collation_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_collation_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_collation_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_collation_stmt(this); - } - } - - public final Create_collation_stmtContext create_collation_stmt() throws RecognitionException { - Create_collation_stmtContext _localctx = new Create_collation_stmtContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_create_collation_stmt); - int _la; - try { - setState(2311); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - { - setState(2288); - match(CREATE); - setState(2289); - match(COLLATION); - setState(2293); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(2290); - match(IF); - setState(2291); - match(NOT); - setState(2292); - match(EXISTS); - } - } - - setState(2295); - name_(); - setState(2296); - match(OPEN_PAREN); - setState(2297); - create_collation_opt_list(); - setState(2298); - match(CLOSE_PAREN); - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - { - setState(2300); - match(CREATE); - setState(2301); - match(COLLATION); - setState(2305); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(2302); - match(IF); - setState(2303); - match(NOT); - setState(2304); - match(EXISTS); - } - } - - setState(2307); - name_(); - setState(2308); - match(FROM); - setState(2309); - name_(); - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_conversion_stmtContext extends ParserRuleContext { - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode CONVERSION() { return getToken(PostgreSqlParser.CONVERSION, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public List SINGLEQ_STRING_LITERAL() { return getTokens(PostgreSqlParser.SINGLEQ_STRING_LITERAL); } - public TerminalNode SINGLEQ_STRING_LITERAL(int i) { - return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, i); - } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } - public Create_conversion_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_conversion_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_conversion_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_conversion_stmt(this); - } - } - - public final Create_conversion_stmtContext create_conversion_stmt() throws RecognitionException { - Create_conversion_stmtContext _localctx = new Create_conversion_stmtContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_create_conversion_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2313); - match(CREATE); - setState(2315); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==DEFAULT) { - { - setState(2314); - match(DEFAULT); - } - } - - setState(2317); - match(CONVERSION); - setState(2318); - identifier(0); - setState(2319); - match(FOR); - setState(2320); - match(SINGLEQ_STRING_LITERAL); - setState(2321); - match(TO); - setState(2322); - match(SINGLEQ_STRING_LITERAL); - setState(2323); - match(FROM); - setState(2324); - name_(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_database_stmtContext extends ParserRuleContext { - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public List EQUAL() { return getTokens(PostgreSqlParser.EQUAL); } - public TerminalNode EQUAL(int i) { - return getToken(PostgreSqlParser.EQUAL, i); - } - public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } - public TerminalNode ENCODING() { return getToken(PostgreSqlParser.ENCODING, 0); } - public TerminalNode LC_COLLATE() { return getToken(PostgreSqlParser.LC_COLLATE, 0); } - public TerminalNode LC_CTYPE() { return getToken(PostgreSqlParser.LC_CTYPE, 0); } - public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } - public TerminalNode ALLOW_CONNECTIONS() { return getToken(PostgreSqlParser.ALLOW_CONNECTIONS, 0); } - public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } - public TerminalNode LIMIT() { return getToken(PostgreSqlParser.LIMIT, 0); } - public List parameterOrIntegerLiteral() { - return getRuleContexts(ParameterOrIntegerLiteralContext.class); - } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral(int i) { - return getRuleContext(ParameterOrIntegerLiteralContext.class,i); - } - public TerminalNode IS_TEMPLATE() { return getToken(PostgreSqlParser.IS_TEMPLATE, 0); } - public Create_database_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_database_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_database_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_database_stmt(this); - } - } - - public final Create_database_stmtContext create_database_stmt() throws RecognitionException { - Create_database_stmtContext _localctx = new Create_database_stmtContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_create_database_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2326); - match(CREATE); - setState(2327); - match(DATABASE); - setState(2328); - name_(); - { - setState(2330); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(2329); - match(WITH); - } - } - - setState(2335); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OWNER) { - { - setState(2332); - match(OWNER); - setState(2333); - match(EQUAL); - setState(2334); - name_(); - } - } - - setState(2340); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TEMPLATE) { - { - setState(2337); - match(TEMPLATE); - setState(2338); - match(EQUAL); - setState(2339); - name_(); - } - } - - setState(2345); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ENCODING) { - { - setState(2342); - match(ENCODING); - setState(2343); - match(EQUAL); - setState(2344); - name_(); - } - } - - setState(2350); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LC_COLLATE) { - { - setState(2347); - match(LC_COLLATE); - setState(2348); - match(EQUAL); - setState(2349); - name_(); - } - } - - setState(2355); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LC_CTYPE) { - { - setState(2352); - match(LC_CTYPE); - setState(2353); - match(EQUAL); - setState(2354); - name_(); - } - } - - setState(2360); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TABLESPACE) { - { - setState(2357); - match(TABLESPACE); - setState(2358); - match(EQUAL); - setState(2359); - name_(); - } - } - - setState(2365); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ALLOW_CONNECTIONS) { - { - setState(2362); - match(ALLOW_CONNECTIONS); - setState(2363); - match(EQUAL); - setState(2364); - name_(); - } - } - - setState(2371); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CONNECTION) { - { - setState(2367); - match(CONNECTION); - setState(2368); - match(LIMIT); - setState(2369); - match(EQUAL); - setState(2370); - parameterOrIntegerLiteral(); - } - } - - setState(2376); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IS_TEMPLATE) { - { - setState(2373); - match(IS_TEMPLATE); - setState(2374); - match(EQUAL); - setState(2375); - parameterOrIntegerLiteral(); - } - } - - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Domain_constraintContext extends ParserRuleContext { - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode NULL() { return getToken(PostgreSqlParser.NULL, 0); } - public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public ExprContext expr() { - return getRuleContext(ExprContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public Domain_constraintContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_domain_constraint; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDomain_constraint(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDomain_constraint(this); - } - } - - public final Domain_constraintContext domain_constraint() throws RecognitionException { - Domain_constraintContext _localctx = new Domain_constraintContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_domain_constraint); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2380); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CONSTRAINT) { - { - setState(2378); - match(CONSTRAINT); - setState(2379); - name_(); - } - } - - setState(2390); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NOT: - { - setState(2382); - match(NOT); - setState(2383); - match(NULL); - } - break; - case NULL: - { - setState(2384); - match(NULL); - } - break; - case CHECK: - { - setState(2385); - match(CHECK); - setState(2386); - match(OPEN_PAREN); - setState(2387); - expr(0); - setState(2388); - match(CLOSE_PAREN); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_domain_stmtContext extends ParserRuleContext { - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode DOMAIN() { return getToken(PostgreSqlParser.DOMAIN, 0); } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public Data_typeContext data_type() { - return getRuleContext(Data_typeContext.class,0); - } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public List domain_constraint() { - return getRuleContexts(Domain_constraintContext.class); - } - public Domain_constraintContext domain_constraint(int i) { - return getRuleContext(Domain_constraintContext.class,i); - } - public List COLLATE() { return getTokens(PostgreSqlParser.COLLATE); } - public TerminalNode COLLATE(int i) { - return getToken(PostgreSqlParser.COLLATE, i); - } - public List DEFAULT() { return getTokens(PostgreSqlParser.DEFAULT); } - public TerminalNode DEFAULT(int i) { - return getToken(PostgreSqlParser.DEFAULT, i); - } - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public Create_domain_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_domain_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_domain_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_domain_stmt(this); - } - } - - public final Create_domain_stmtContext create_domain_stmt() throws RecognitionException { - Create_domain_stmtContext _localctx = new Create_domain_stmtContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_create_domain_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2392); - match(CREATE); - setState(2393); - match(DOMAIN); - setState(2394); - name_(); - setState(2396); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(2395); - match(AS); - } - } - - setState(2398); - data_type(); - setState(2406); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & 2147484673L) != 0) || _la==DEFAULT || _la==NOT || _la==NULL) { - { - setState(2404); - _errHandler.sync(this); - switch (_input.LA(1)) { - case COLLATE: - { - { - setState(2399); - match(COLLATE); - setState(2400); - name_(); - } - } - break; - case DEFAULT: - { - { - setState(2401); - match(DEFAULT); - setState(2402); - expr(0); - } - } - break; - case CHECK: - case CONSTRAINT: - case NOT: - case NULL: - { - setState(2403); - domain_constraint(); - } - break; - default: - throw new NoViableAltException(this); - } - } - setState(2408); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_event_trigger_condContext extends ParserRuleContext { - public IdentifierContext filter_stmt; - public TerminalNode IN() { return getToken(PostgreSqlParser.IN, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List SINGLEQ_STRING_LITERAL() { return getTokens(PostgreSqlParser.SINGLEQ_STRING_LITERAL); } - public TerminalNode SINGLEQ_STRING_LITERAL(int i) { - return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, i); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public List AND() { return getTokens(PostgreSqlParser.AND); } - public TerminalNode AND(int i) { - return getToken(PostgreSqlParser.AND, i); - } - public List create_event_trigger_cond() { - return getRuleContexts(Create_event_trigger_condContext.class); - } - public Create_event_trigger_condContext create_event_trigger_cond(int i) { - return getRuleContext(Create_event_trigger_condContext.class,i); - } - public Create_event_trigger_condContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_event_trigger_cond; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_event_trigger_cond(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_event_trigger_cond(this); - } - } - - public final Create_event_trigger_condContext create_event_trigger_cond() throws RecognitionException { - Create_event_trigger_condContext _localctx = new Create_event_trigger_condContext(_ctx, getState()); - enterRule(_localctx, 132, RULE_create_event_trigger_cond); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2409); - ((Create_event_trigger_condContext)_localctx).filter_stmt = identifier(0); - setState(2410); - match(IN); - setState(2411); - match(OPEN_PAREN); - setState(2412); - match(SINGLEQ_STRING_LITERAL); - setState(2417); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(2413); - match(COMMA); - setState(2414); - match(SINGLEQ_STRING_LITERAL); - } - } - setState(2419); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2420); - match(CLOSE_PAREN); - setState(2425); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,186,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2421); - match(AND); - setState(2422); - create_event_trigger_cond(); - } - } - } - setState(2427); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,186,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_event_trigger_stmtContext extends ParserRuleContext { - public IdentifierContext trigger; - public IdentifierContext event; - public IdentifierContext fn_name; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } - public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } - public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } - public Create_event_trigger_condContext create_event_trigger_cond() { - return getRuleContext(Create_event_trigger_condContext.class,0); - } - public Create_event_trigger_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_event_trigger_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_event_trigger_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_event_trigger_stmt(this); - } - } - - public final Create_event_trigger_stmtContext create_event_trigger_stmt() throws RecognitionException { - Create_event_trigger_stmtContext _localctx = new Create_event_trigger_stmtContext(_ctx, getState()); - enterRule(_localctx, 134, RULE_create_event_trigger_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2428); - match(CREATE); - setState(2429); - match(EVENT); - setState(2430); - match(TRIGGER); - setState(2431); - ((Create_event_trigger_stmtContext)_localctx).trigger = identifier(0); - setState(2432); - match(ON); - setState(2433); - ((Create_event_trigger_stmtContext)_localctx).event = identifier(0); - setState(2436); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHEN) { - { - setState(2434); - match(WHEN); - setState(2435); - create_event_trigger_cond(); - } - } - - setState(2438); - match(EXECUTE); - setState(2439); - match(PROCEDURE); - setState(2440); - ((Create_event_trigger_stmtContext)_localctx).fn_name = identifier(0); - setState(2441); - match(OPEN_PAREN); - setState(2442); - match(CLOSE_PAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_foreign_data_optionsContext extends ParserRuleContext { - public Name_Context opt; - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public List create_foreign_data_options() { - return getRuleContexts(Create_foreign_data_optionsContext.class); - } - public Create_foreign_data_optionsContext create_foreign_data_options(int i) { - return getRuleContext(Create_foreign_data_optionsContext.class,i); - } - public Create_foreign_data_optionsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_foreign_data_options; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_foreign_data_options(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_foreign_data_options(this); - } - } - - public final Create_foreign_data_optionsContext create_foreign_data_options() throws RecognitionException { - Create_foreign_data_optionsContext _localctx = new Create_foreign_data_optionsContext(_ctx, getState()); - enterRule(_localctx, 136, RULE_create_foreign_data_options); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2444); - ((Create_foreign_data_optionsContext)_localctx).opt = name_(); - setState(2445); - match(SINGLEQ_STRING_LITERAL); - setState(2450); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,188,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2446); - match(COMMA); - setState(2447); - create_foreign_data_options(); - } - } - } - setState(2452); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,188,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_foreign_data_stmtContext extends ParserRuleContext { - public IdentifierContext wrapper; - public IdentifierContext handler; - public IdentifierContext validator; - public Create_foreign_data_optionsContext opts; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } - public TerminalNode DATA() { return getToken(PostgreSqlParser.DATA, 0); } - public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List HANDLER() { return getTokens(PostgreSqlParser.HANDLER); } - public TerminalNode HANDLER(int i) { - return getToken(PostgreSqlParser.HANDLER, i); - } - public List NO() { return getTokens(PostgreSqlParser.NO); } - public TerminalNode NO(int i) { - return getToken(PostgreSqlParser.NO, i); - } - public TerminalNode VALIDATOR() { return getToken(PostgreSqlParser.VALIDATOR, 0); } - public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Create_foreign_data_optionsContext create_foreign_data_options() { - return getRuleContext(Create_foreign_data_optionsContext.class,0); - } - public Create_foreign_data_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_foreign_data_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_foreign_data_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_foreign_data_stmt(this); - } - } - - public final Create_foreign_data_stmtContext create_foreign_data_stmt() throws RecognitionException { - Create_foreign_data_stmtContext _localctx = new Create_foreign_data_stmtContext(_ctx, getState()); - enterRule(_localctx, 138, RULE_create_foreign_data_stmt); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2453); - match(CREATE); - setState(2454); - match(FOREIGN); - setState(2455); - match(DATA); - setState(2456); - match(WRAPPER); - setState(2457); - ((Create_foreign_data_stmtContext)_localctx).wrapper = identifier(0); - setState(2464); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,190,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(2462); - _errHandler.sync(this); - switch (_input.LA(1)) { - case HANDLER: - { - setState(2458); - match(HANDLER); - setState(2459); - ((Create_foreign_data_stmtContext)_localctx).handler = identifier(0); - } - break; - case NO: - { - setState(2460); - match(NO); - setState(2461); - match(HANDLER); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(2466); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,190,_ctx); - } - setState(2471); - _errHandler.sync(this); - switch (_input.LA(1)) { - case VALIDATOR: - { - setState(2467); - match(VALIDATOR); - setState(2468); - ((Create_foreign_data_stmtContext)_localctx).validator = identifier(0); - } - break; - case NO: - { - setState(2469); - match(NO); - setState(2470); - match(VALIDATOR); - } - break; - case EOF: - case OPTIONS: - case CLOSE_PAREN: - case SEMI: - break; - default: - break; - } - setState(2478); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPTIONS) { - { - setState(2473); - match(OPTIONS); - setState(2474); - match(OPEN_PAREN); - setState(2475); - ((Create_foreign_data_stmtContext)_localctx).opts = create_foreign_data_options(); - setState(2476); - match(CLOSE_PAREN); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_foreign_table_stmtContext extends ParserRuleContext { - public IdentifierContext table_name_TODO; - public IdentifierContext column_name_TODO; - public IdentifierContext column_type; - public Create_foreign_data_optionsContext opts; - public Name_Context server_name; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public List OPTIONS() { return getTokens(PostgreSqlParser.OPTIONS); } - public TerminalNode OPTIONS(int i) { - return getToken(PostgreSqlParser.OPTIONS, i); - } - public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } - public Create_collation_optContext create_collation_opt() { - return getRuleContext(Create_collation_optContext.class,0); - } - public TerminalNode INHERITS() { return getToken(PostgreSqlParser.INHERITS, 0); } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public List create_foreign_data_options() { - return getRuleContexts(Create_foreign_data_optionsContext.class); - } - public Create_foreign_data_optionsContext create_foreign_data_options(int i) { - return getRuleContext(Create_foreign_data_optionsContext.class,i); - } - public Create_foreign_table_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_foreign_table_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_foreign_table_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_foreign_table_stmt(this); - } - } - - public final Create_foreign_table_stmtContext create_foreign_table_stmt() throws RecognitionException { - Create_foreign_table_stmtContext _localctx = new Create_foreign_table_stmtContext(_ctx, getState()); - enterRule(_localctx, 140, RULE_create_foreign_table_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2480); - match(CREATE); - setState(2481); - match(FOREIGN); - setState(2482); - match(TABLE); - setState(2486); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(2483); - match(IF); - setState(2484); - match(NOT); - setState(2485); - match(EXISTS); - } - } - - setState(2488); - ((Create_foreign_table_stmtContext)_localctx).table_name_TODO = identifier(0); - setState(2489); - match(OPEN_PAREN); - setState(2490); - ((Create_foreign_table_stmtContext)_localctx).column_name_TODO = identifier(0); - setState(2491); - ((Create_foreign_table_stmtContext)_localctx).column_type = identifier(0); - setState(2497); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPTIONS) { - { - setState(2492); - match(OPTIONS); - setState(2493); - match(OPEN_PAREN); - setState(2494); - ((Create_foreign_table_stmtContext)_localctx).opts = create_foreign_data_options(); - setState(2495); - match(CLOSE_PAREN); - } - } - - setState(2501); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLLATE) { - { - setState(2499); - match(COLLATE); - setState(2500); - create_collation_opt(); - } - } - - setState(2503); - match(CLOSE_PAREN); - setState(2506); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INHERITS) { - { - setState(2504); - match(INHERITS); - setState(2505); - name_list(); - } - } - - setState(2508); - match(SERVER); - setState(2509); - ((Create_foreign_table_stmtContext)_localctx).server_name = name_(); - setState(2515); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPTIONS) { - { - setState(2510); - match(OPTIONS); - setState(2511); - match(OPEN_PAREN); - setState(2512); - ((Create_foreign_table_stmtContext)_localctx).opts = create_foreign_data_options(); - setState(2513); - match(CLOSE_PAREN); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_function_stmtContext extends ParserRuleContext { - public Name_Context fn_name; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } - public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } - public Create_function_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_function_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_function_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_function_stmt(this); - } - } - - public final Create_function_stmtContext create_function_stmt() throws RecognitionException { - Create_function_stmtContext _localctx = new Create_function_stmtContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_create_function_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2517); - match(CREATE); - setState(2520); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OR) { - { - setState(2518); - match(OR); - setState(2519); - match(REPLACE); - } - } - - setState(2522); - match(FUNCTION); - setState(2523); - ((Create_function_stmtContext)_localctx).fn_name = name_(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_group_stmtContext extends ParserRuleContext { - public IdentifierContext group; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public List GROUP() { return getTokens(PostgreSqlParser.GROUP); } - public TerminalNode GROUP(int i) { - return getToken(PostgreSqlParser.GROUP, i); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public List SUPERUSER() { return getTokens(PostgreSqlParser.SUPERUSER); } - public TerminalNode SUPERUSER(int i) { - return getToken(PostgreSqlParser.SUPERUSER, i); - } - public List NOSUPERUSER() { return getTokens(PostgreSqlParser.NOSUPERUSER); } - public TerminalNode NOSUPERUSER(int i) { - return getToken(PostgreSqlParser.NOSUPERUSER, i); - } - public List CREATEDB() { return getTokens(PostgreSqlParser.CREATEDB); } - public TerminalNode CREATEDB(int i) { - return getToken(PostgreSqlParser.CREATEDB, i); - } - public List NOCREATEDB() { return getTokens(PostgreSqlParser.NOCREATEDB); } - public TerminalNode NOCREATEDB(int i) { - return getToken(PostgreSqlParser.NOCREATEDB, i); - } - public List CREATEROLE() { return getTokens(PostgreSqlParser.CREATEROLE); } - public TerminalNode CREATEROLE(int i) { - return getToken(PostgreSqlParser.CREATEROLE, i); - } - public List NOCREATEROLE() { return getTokens(PostgreSqlParser.NOCREATEROLE); } - public TerminalNode NOCREATEROLE(int i) { - return getToken(PostgreSqlParser.NOCREATEROLE, i); - } - public List CREATEUSER() { return getTokens(PostgreSqlParser.CREATEUSER); } - public TerminalNode CREATEUSER(int i) { - return getToken(PostgreSqlParser.CREATEUSER, i); - } - public List NOCREATEUSER() { return getTokens(PostgreSqlParser.NOCREATEUSER); } - public TerminalNode NOCREATEUSER(int i) { - return getToken(PostgreSqlParser.NOCREATEUSER, i); - } - public List INHERIT() { return getTokens(PostgreSqlParser.INHERIT); } - public TerminalNode INHERIT(int i) { - return getToken(PostgreSqlParser.INHERIT, i); - } - public List NOINHERIT() { return getTokens(PostgreSqlParser.NOINHERIT); } - public TerminalNode NOINHERIT(int i) { - return getToken(PostgreSqlParser.NOINHERIT, i); - } - public List LOGIN() { return getTokens(PostgreSqlParser.LOGIN); } - public TerminalNode LOGIN(int i) { - return getToken(PostgreSqlParser.LOGIN, i); - } - public List NOLOGIN() { return getTokens(PostgreSqlParser.NOLOGIN); } - public TerminalNode NOLOGIN(int i) { - return getToken(PostgreSqlParser.NOLOGIN, i); - } - public List PASSWORD() { return getTokens(PostgreSqlParser.PASSWORD); } - public TerminalNode PASSWORD(int i) { - return getToken(PostgreSqlParser.PASSWORD, i); - } - public List VALID() { return getTokens(PostgreSqlParser.VALID); } - public TerminalNode VALID(int i) { - return getToken(PostgreSqlParser.VALID, i); - } - public List UNTIL() { return getTokens(PostgreSqlParser.UNTIL); } - public TerminalNode UNTIL(int i) { - return getToken(PostgreSqlParser.UNTIL, i); - } - public List SINGLEQ_STRING_LITERAL() { return getTokens(PostgreSqlParser.SINGLEQ_STRING_LITERAL); } - public TerminalNode SINGLEQ_STRING_LITERAL(int i) { - return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, i); - } - public List IN() { return getTokens(PostgreSqlParser.IN); } - public TerminalNode IN(int i) { - return getToken(PostgreSqlParser.IN, i); - } - public List ROLE() { return getTokens(PostgreSqlParser.ROLE); } - public TerminalNode ROLE(int i) { - return getToken(PostgreSqlParser.ROLE, i); - } - public List name_list() { - return getRuleContexts(Name_listContext.class); - } - public Name_listContext name_list(int i) { - return getRuleContext(Name_listContext.class,i); - } - public List ADMIN() { return getTokens(PostgreSqlParser.ADMIN); } - public TerminalNode ADMIN(int i) { - return getToken(PostgreSqlParser.ADMIN, i); - } - public List USER() { return getTokens(PostgreSqlParser.USER); } - public TerminalNode USER(int i) { - return getToken(PostgreSqlParser.USER, i); - } - public List SYSID() { return getTokens(PostgreSqlParser.SYSID); } - public TerminalNode SYSID(int i) { - return getToken(PostgreSqlParser.SYSID, i); - } - public List INTEGER_LITERAL() { return getTokens(PostgreSqlParser.INTEGER_LITERAL); } - public TerminalNode INTEGER_LITERAL(int i) { - return getToken(PostgreSqlParser.INTEGER_LITERAL, i); - } - public List NULL() { return getTokens(PostgreSqlParser.NULL); } - public TerminalNode NULL(int i) { - return getToken(PostgreSqlParser.NULL, i); - } - public List ENCRYPTED() { return getTokens(PostgreSqlParser.ENCRYPTED); } - public TerminalNode ENCRYPTED(int i) { - return getToken(PostgreSqlParser.ENCRYPTED, i); - } - public List UNENCRYPTED() { return getTokens(PostgreSqlParser.UNENCRYPTED); } - public TerminalNode UNENCRYPTED(int i) { - return getToken(PostgreSqlParser.UNENCRYPTED, i); - } - public Create_group_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_group_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_group_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_group_stmt(this); - } - } - - public final Create_group_stmtContext create_group_stmt() throws RecognitionException { - Create_group_stmtContext _localctx = new Create_group_stmtContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_create_group_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2525); - match(CREATE); - setState(2526); - match(GROUP); - setState(2527); - ((Create_group_stmtContext)_localctx).group = identifier(0); - setState(2569); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ADMIN || _la==CREATEDB || _la==CREATEUSER || _la==ENCRYPTED || _la==IN || ((((_la - 360)) & ~0x3f) == 0 && ((1L << (_la - 360)) & 144115188075855875L) != 0) || _la==ROLE || ((((_la - 564)) & ~0x3f) == 0 && ((1L << (_la - 564)) & 288300744895889409L) != 0) || ((((_la - 629)) & ~0x3f) == 0 && ((1L << (_la - 629)) & 68451565569L) != 0)) { - { - setState(2529); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(2528); - match(WITH); - } - } - - setState(2565); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - setState(2565); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) { - case 1: - { - setState(2531); - match(SUPERUSER); - } - break; - case 2: - { - setState(2532); - match(NOSUPERUSER); - } - break; - case 3: - { - setState(2533); - match(CREATEDB); - } - break; - case 4: - { - setState(2534); - match(NOCREATEDB); - } - break; - case 5: - { - setState(2535); - match(CREATEROLE); - } - break; - case 6: - { - setState(2536); - match(NOCREATEROLE); - } - break; - case 7: - { - setState(2537); - match(CREATEUSER); - } - break; - case 8: - { - setState(2538); - match(NOCREATEUSER); - } - break; - case 9: - { - setState(2539); - match(INHERIT); - } - break; - case 10: - { - setState(2540); - match(NOINHERIT); - } - break; - case 11: - { - setState(2541); - match(LOGIN); - } - break; - case 12: - { - setState(2542); - match(NOLOGIN); - } - break; - case 13: - { - setState(2544); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ENCRYPTED || _la==UNENCRYPTED) { - { - setState(2543); - _la = _input.LA(1); - if ( !(_la==ENCRYPTED || _la==UNENCRYPTED) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(2546); - match(PASSWORD); - setState(2547); - _la = _input.LA(1); - if ( !(_la==NULL || _la==SINGLEQ_STRING_LITERAL) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - case 14: - { - setState(2548); - match(VALID); - setState(2549); - match(UNTIL); - setState(2550); - match(SINGLEQ_STRING_LITERAL); - } - break; - case 15: - { - setState(2551); - match(IN); - setState(2552); - match(ROLE); - setState(2553); - name_list(); - } - break; - case 16: - { - setState(2554); - match(IN); - setState(2555); - match(GROUP); - setState(2556); - name_list(); - } - break; - case 17: - { - setState(2557); - match(ROLE); - setState(2558); - name_list(); - } - break; - case 18: - { - setState(2559); - match(ADMIN); - setState(2560); - name_list(); - } - break; - case 19: - { - setState(2561); - match(USER); - setState(2562); - name_list(); - } - break; - case 20: - { - setState(2563); - match(SYSID); - setState(2564); - match(INTEGER_LITERAL); - } - break; - } - } - setState(2567); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==ADMIN || _la==CREATEDB || _la==CREATEUSER || _la==ENCRYPTED || _la==IN || ((((_la - 360)) & ~0x3f) == 0 && ((1L << (_la - 360)) & 144115188075855875L) != 0) || _la==ROLE || ((((_la - 564)) & ~0x3f) == 0 && ((1L << (_la - 564)) & 288300744895889409L) != 0) || ((((_la - 629)) & ~0x3f) == 0 && ((1L << (_la - 629)) & 68451041281L) != 0) ); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_index_stmtContext extends ParserRuleContext { - public IdentifierContext index_name; - public IdentifierContext tableName; - public IdentifierContext tablespace_name; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode UNIQUE() { return getToken(PostgreSqlParser.UNIQUE, 0); } - public TerminalNode CONCURRENTLY() { return getToken(PostgreSqlParser.CONCURRENTLY, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public Index_methodContext index_method() { - return getRuleContext(Index_methodContext.class,0); - } - public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } - public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } - public PredicateContext predicate() { - return getRuleContext(PredicateContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Create_index_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_index_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_index_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_index_stmt(this); - } - } - - public final Create_index_stmtContext create_index_stmt() throws RecognitionException { - Create_index_stmtContext _localctx = new Create_index_stmtContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_create_index_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2571); - match(CREATE); - setState(2573); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==UNIQUE) { - { - setState(2572); - match(UNIQUE); - } - } - - setState(2575); - match(INDEX); - setState(2577); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CONCURRENTLY) { - { - setState(2576); - match(CONCURRENTLY); - } - } - - setState(2585); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245456777353L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206585526350118915L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3120954820635131899L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 290271069733039L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3170536334544601087L) != 0)) { - { - setState(2582); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(2579); - match(IF); - setState(2580); - match(NOT); - setState(2581); - match(EXISTS); - } - } - - setState(2584); - ((Create_index_stmtContext)_localctx).index_name = identifier(0); - } - } - - setState(2587); - match(ON); - setState(2588); - ((Create_index_stmtContext)_localctx).tableName = identifier(0); - setState(2591); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==USING) { - { - setState(2589); - match(USING); - setState(2590); - index_method(); - } - } - - setState(2595); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TABLESPACE) { - { - setState(2593); - match(TABLESPACE); - setState(2594); - ((Create_index_stmtContext)_localctx).tablespace_name = identifier(0); - } - } - - setState(2599); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2597); - match(WHERE); - setState(2598); - predicate(0); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_language_stmtContext extends ParserRuleContext { - public IdentifierContext language_name; - public IdentifierContext call_handler; - public IdentifierContext inline_handler; - public IdentifierContext valfunction; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } - public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } - public TerminalNode PROCEDURAL() { return getToken(PostgreSqlParser.PROCEDURAL, 0); } - public TerminalNode HANDLER() { return getToken(PostgreSqlParser.HANDLER, 0); } - public TerminalNode TRUSTED() { return getToken(PostgreSqlParser.TRUSTED, 0); } - public TerminalNode INLINE() { return getToken(PostgreSqlParser.INLINE, 0); } - public TerminalNode VALIDATOR() { return getToken(PostgreSqlParser.VALIDATOR, 0); } - public Create_language_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_language_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_language_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_language_stmt(this); - } - } - - public final Create_language_stmtContext create_language_stmt() throws RecognitionException { - Create_language_stmtContext _localctx = new Create_language_stmtContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_create_language_stmt); - int _la; - try { - setState(2634); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - { - setState(2601); - match(CREATE); - setState(2604); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OR) { - { - setState(2602); - match(OR); - setState(2603); - match(REPLACE); - } - } - - setState(2607); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PROCEDURAL) { - { - setState(2606); - match(PROCEDURAL); - } - } - - setState(2609); - match(LANGUAGE); - setState(2610); - ((Create_language_stmtContext)_localctx).language_name = identifier(0); - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - { - setState(2611); - match(CREATE); - setState(2614); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OR) { - { - setState(2612); - match(OR); - setState(2613); - match(REPLACE); - } - } - - setState(2617); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TRUSTED) { - { - setState(2616); - match(TRUSTED); - } - } - - setState(2620); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PROCEDURAL) { - { - setState(2619); - match(PROCEDURAL); - } - } - - setState(2622); - match(LANGUAGE); - setState(2623); - ((Create_language_stmtContext)_localctx).language_name = identifier(0); - setState(2624); - match(HANDLER); - setState(2625); - ((Create_language_stmtContext)_localctx).call_handler = identifier(0); - setState(2628); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INLINE) { - { - setState(2626); - match(INLINE); - setState(2627); - ((Create_language_stmtContext)_localctx).inline_handler = identifier(0); - } - } - - setState(2632); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==VALIDATOR) { - { - setState(2630); - match(VALIDATOR); - setState(2631); - ((Create_language_stmtContext)_localctx).valfunction = identifier(0); - } - } - - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_materialized_view_stmtContext extends ParserRuleContext { - public IdentifierContext tableName; - public Identifier_listContext columns; - public IdentifierContext tablespace_name; - public Select_stmtContext query; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } - public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public List WITH() { return getTokens(PostgreSqlParser.WITH); } - public TerminalNode WITH(int i) { - return getToken(PostgreSqlParser.WITH, i); - } - public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } - public TerminalNode DATA() { return getToken(PostgreSqlParser.DATA, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } - public Create_materialized_view_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_materialized_view_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_materialized_view_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_materialized_view_stmt(this); - } - } - - public final Create_materialized_view_stmtContext create_materialized_view_stmt() throws RecognitionException { - Create_materialized_view_stmtContext _localctx = new Create_materialized_view_stmtContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_create_materialized_view_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2636); - match(CREATE); - setState(2637); - match(MATERIALIZED); - setState(2638); - match(VIEW); - setState(2642); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(2639); - match(IF); - setState(2640); - match(NOT); - setState(2641); - match(EXISTS); - } - } - - setState(2644); - ((Create_materialized_view_stmtContext)_localctx).tableName = identifier(0); - setState(2649); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(2645); - match(OPEN_PAREN); - setState(2646); - ((Create_materialized_view_stmtContext)_localctx).columns = identifier_list(); - setState(2647); - match(CLOSE_PAREN); - } - } - - setState(2652); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(2651); - match(WITH); - } - } - - setState(2656); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TABLESPACE) { - { - setState(2654); - match(TABLESPACE); - setState(2655); - ((Create_materialized_view_stmtContext)_localctx).tablespace_name = identifier(0); - } - } - - setState(2658); - match(AS); - setState(2659); - ((Create_materialized_view_stmtContext)_localctx).query = select_stmt(); - setState(2665); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(2660); - match(WITH); - setState(2662); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NO) { - { - setState(2661); - match(NO); - } - } - - setState(2664); - match(DATA); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_operator_stmtContext extends ParserRuleContext { - public IdentifierContext opName; - public IdentifierContext function_name; - public Name_Context left_type; - public Name_Context right_type; - public Name_Context com_op; - public Name_Context neg_op; - public Name_Context res_proc; - public Name_Context join_proc; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } - public List EQUAL() { return getTokens(PostgreSqlParser.EQUAL); } - public TerminalNode EQUAL(int i) { - return getToken(PostgreSqlParser.EQUAL, i); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public TerminalNode LEFTARG() { return getToken(PostgreSqlParser.LEFTARG, 0); } - public TerminalNode RIGHTARG() { return getToken(PostgreSqlParser.RIGHTARG, 0); } - public TerminalNode COMMUTATOR() { return getToken(PostgreSqlParser.COMMUTATOR, 0); } - public TerminalNode NEGATOR() { return getToken(PostgreSqlParser.NEGATOR, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public TerminalNode JOIN() { return getToken(PostgreSqlParser.JOIN, 0); } - public TerminalNode HASHES() { return getToken(PostgreSqlParser.HASHES, 0); } - public TerminalNode MERGES() { return getToken(PostgreSqlParser.MERGES, 0); } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public Create_operator_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_operator_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_operator_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_operator_stmt(this); - } - } - - public final Create_operator_stmtContext create_operator_stmt() throws RecognitionException { - Create_operator_stmtContext _localctx = new Create_operator_stmtContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_create_operator_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2667); - match(CREATE); - setState(2668); - match(OPERATOR); - setState(2669); - ((Create_operator_stmtContext)_localctx).opName = identifier(0); - setState(2670); - match(OPEN_PAREN); - setState(2671); - match(PROCEDURE); - setState(2672); - match(EQUAL); - setState(2673); - ((Create_operator_stmtContext)_localctx).function_name = identifier(0); - setState(2678); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) { - case 1: - { - setState(2674); - match(COMMA); - setState(2675); - match(LEFTARG); - setState(2676); - match(EQUAL); - setState(2677); - ((Create_operator_stmtContext)_localctx).left_type = name_(); - } - break; - } - setState(2684); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,226,_ctx) ) { - case 1: - { - setState(2680); - match(COMMA); - setState(2681); - match(RIGHTARG); - setState(2682); - match(EQUAL); - setState(2683); - ((Create_operator_stmtContext)_localctx).right_type = name_(); - } - break; - } - setState(2690); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) { - case 1: - { - setState(2686); - match(COMMA); - setState(2687); - match(COMMUTATOR); - setState(2688); - match(EQUAL); - setState(2689); - ((Create_operator_stmtContext)_localctx).com_op = name_(); - } - break; - } - setState(2696); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) { - case 1: - { - setState(2692); - match(COMMA); - setState(2693); - match(NEGATOR); - setState(2694); - match(EQUAL); - setState(2695); - ((Create_operator_stmtContext)_localctx).neg_op = name_(); - } - break; - } - setState(2702); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) { - case 1: - { - setState(2698); - match(COMMA); - setState(2699); - match(RESTRICT); - setState(2700); - match(EQUAL); - setState(2701); - ((Create_operator_stmtContext)_localctx).res_proc = name_(); - } - break; - } - setState(2708); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,230,_ctx) ) { - case 1: - { - setState(2704); - match(COMMA); - setState(2705); - match(JOIN); - setState(2706); - match(EQUAL); - setState(2707); - ((Create_operator_stmtContext)_localctx).join_proc = name_(); - } - break; - } - setState(2712); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) { - case 1: - { - setState(2710); - match(COMMA); - setState(2711); - match(HASHES); - } - break; - } - setState(2716); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2714); - match(COMMA); - setState(2715); - match(MERGES); - } - } - - setState(2718); - match(CLOSE_PAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_operator_class_optContext extends ParserRuleContext { - public Token strategy_number; - public IdentifierContext opName; - public Token support_number; - public IdentifierContext func_name_; - public IdentifierContext storage_type; - public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } - public Data_type_listContext data_type_list() { - return getRuleContext(Data_type_listContext.class,0); - } - public TerminalNode STORAGE() { return getToken(PostgreSqlParser.STORAGE, 0); } - public Create_operator_class_optContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_operator_class_opt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_operator_class_opt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_operator_class_opt(this); - } - } - - public final Create_operator_class_optContext create_operator_class_opt() throws RecognitionException { - Create_operator_class_optContext _localctx = new Create_operator_class_optContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_create_operator_class_opt); - int _la; - try { - setState(2750); - _errHandler.sync(this); - switch (_input.LA(1)) { - case OPERATOR: - enterOuterAlt(_localctx, 1); - { - { - setState(2720); - match(OPERATOR); - setState(2721); - ((Create_operator_class_optContext)_localctx).strategy_number = match(INTEGER_LITERAL); - setState(2722); - ((Create_operator_class_optContext)_localctx).opName = identifier(0); - setState(2729); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(2723); - match(OPEN_PAREN); - setState(2724); - identifier(0); - setState(2725); - match(COMMA); - setState(2726); - identifier(0); - setState(2727); - match(CLOSE_PAREN); - } - } - - } - } - break; - case FUNCTION: - enterOuterAlt(_localctx, 2); - { - { - setState(2731); - match(FUNCTION); - setState(2732); - ((Create_operator_class_optContext)_localctx).support_number = match(INTEGER_LITERAL); - setState(2741); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(2733); - match(OPEN_PAREN); - setState(2734); - identifier(0); - setState(2737); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(2735); - match(COMMA); - setState(2736); - identifier(0); - } - } - - setState(2739); - match(CLOSE_PAREN); - } - } - - setState(2743); - ((Create_operator_class_optContext)_localctx).func_name_ = identifier(0); - setState(2744); - match(OPEN_PAREN); - setState(2745); - data_type_list(); - setState(2746); - match(CLOSE_PAREN); - } - } - break; - case STORAGE: - enterOuterAlt(_localctx, 3); - { - { - setState(2748); - match(STORAGE); - setState(2749); - ((Create_operator_class_optContext)_localctx).storage_type = identifier(0); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_operator_class_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext op_type; - public IdentifierContext family_name; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } - public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public TerminalNode TYPE() { return getToken(PostgreSqlParser.TYPE, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public Index_methodContext index_method() { - return getRuleContext(Index_methodContext.class,0); - } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public List create_operator_class_opt() { - return getRuleContexts(Create_operator_class_optContext.class); - } - public Create_operator_class_optContext create_operator_class_opt(int i) { - return getRuleContext(Create_operator_class_optContext.class,i); - } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } - public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Create_operator_class_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_operator_class_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_operator_class_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_operator_class_stmt(this); - } - } - - public final Create_operator_class_stmtContext create_operator_class_stmt() throws RecognitionException { - Create_operator_class_stmtContext _localctx = new Create_operator_class_stmtContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_create_operator_class_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2752); - match(CREATE); - setState(2753); - match(OPERATOR); - setState(2754); - match(CLASS); - setState(2755); - ((Create_operator_class_stmtContext)_localctx).name = identifier(0); - setState(2757); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==DEFAULT) { - { - setState(2756); - match(DEFAULT); - } - } - - setState(2759); - match(FOR); - setState(2760); - match(TYPE); - setState(2761); - ((Create_operator_class_stmtContext)_localctx).op_type = identifier(0); - setState(2762); - match(USING); - setState(2763); - index_method(); - setState(2766); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FAMILY) { - { - setState(2764); - match(FAMILY); - setState(2765); - ((Create_operator_class_stmtContext)_localctx).family_name = identifier(0); - } - } - - setState(2768); - match(AS); - setState(2769); - create_operator_class_opt(); - setState(2774); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(2770); - match(COMMA); - setState(2771); - create_operator_class_opt(); - } - } - setState(2776); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_operator_family_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } - public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public Index_methodContext index_method() { - return getRuleContext(Index_methodContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Create_operator_family_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_operator_family_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_operator_family_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_operator_family_stmt(this); - } - } - - public final Create_operator_family_stmtContext create_operator_family_stmt() throws RecognitionException { - Create_operator_family_stmtContext _localctx = new Create_operator_family_stmtContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_create_operator_family_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2777); - match(CREATE); - setState(2778); - match(OPERATOR); - setState(2779); - match(FAMILY); - setState(2780); - ((Create_operator_family_stmtContext)_localctx).name = identifier(0); - setState(2781); - match(USING); - setState(2782); - index_method(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_policy_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext tableName; - public Role_nameContext role; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode POLICY() { return getToken(PostgreSqlParser.POLICY, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List predicate() { - return getRuleContexts(PredicateContext.class); - } - public PredicateContext predicate(int i) { - return getRuleContext(PredicateContext.class,i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } - public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public TerminalNode DELETE() { return getToken(PostgreSqlParser.DELETE, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public Create_policy_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_policy_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_policy_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_policy_stmt(this); - } - } - - public final Create_policy_stmtContext create_policy_stmt() throws RecognitionException { - Create_policy_stmtContext _localctx = new Create_policy_stmtContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_create_policy_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2784); - match(CREATE); - setState(2785); - match(POLICY); - setState(2786); - ((Create_policy_stmtContext)_localctx).name = identifier(0); - setState(2787); - match(ON); - setState(2788); - ((Create_policy_stmtContext)_localctx).tableName = identifier(0); - setState(2791); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FOR) { - { - setState(2789); - match(FOR); - setState(2790); - _la = _input.LA(1); - if ( !(_la==ALL || _la==DELETE || _la==INSERT || _la==SELECT || _la==UPDATE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(2795); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TO) { - { - setState(2793); - match(TO); - setState(2794); - ((Create_policy_stmtContext)_localctx).role = role_name(); - } - } - - setState(2802); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==USING) { - { - setState(2797); - match(USING); - setState(2798); - match(OPEN_PAREN); - setState(2799); - predicate(0); - setState(2800); - match(CLOSE_PAREN); - } - } - - setState(2810); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(2804); - match(WITH); - setState(2805); - match(CHECK); - setState(2806); - match(OPEN_PAREN); - setState(2807); - predicate(0); - setState(2808); - match(CLOSE_PAREN); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_role_stmtContext extends ParserRuleContext { - public Role_nameContext role; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public List ROLE() { return getTokens(PostgreSqlParser.ROLE); } - public TerminalNode ROLE(int i) { - return getToken(PostgreSqlParser.ROLE, i); - } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public List SUPERUSER() { return getTokens(PostgreSqlParser.SUPERUSER); } - public TerminalNode SUPERUSER(int i) { - return getToken(PostgreSqlParser.SUPERUSER, i); - } - public List NOSUPERUSER() { return getTokens(PostgreSqlParser.NOSUPERUSER); } - public TerminalNode NOSUPERUSER(int i) { - return getToken(PostgreSqlParser.NOSUPERUSER, i); - } - public List CREATEDB() { return getTokens(PostgreSqlParser.CREATEDB); } - public TerminalNode CREATEDB(int i) { - return getToken(PostgreSqlParser.CREATEDB, i); - } - public List NOCREATEDB() { return getTokens(PostgreSqlParser.NOCREATEDB); } - public TerminalNode NOCREATEDB(int i) { - return getToken(PostgreSqlParser.NOCREATEDB, i); - } - public List CREATEROLE() { return getTokens(PostgreSqlParser.CREATEROLE); } - public TerminalNode CREATEROLE(int i) { - return getToken(PostgreSqlParser.CREATEROLE, i); - } - public List NOCREATEROLE() { return getTokens(PostgreSqlParser.NOCREATEROLE); } - public TerminalNode NOCREATEROLE(int i) { - return getToken(PostgreSqlParser.NOCREATEROLE, i); - } - public List INHERIT() { return getTokens(PostgreSqlParser.INHERIT); } - public TerminalNode INHERIT(int i) { - return getToken(PostgreSqlParser.INHERIT, i); - } - public List NOINHERIT() { return getTokens(PostgreSqlParser.NOINHERIT); } - public TerminalNode NOINHERIT(int i) { - return getToken(PostgreSqlParser.NOINHERIT, i); - } - public List LOGIN() { return getTokens(PostgreSqlParser.LOGIN); } - public TerminalNode LOGIN(int i) { - return getToken(PostgreSqlParser.LOGIN, i); - } - public List NOLOGIN() { return getTokens(PostgreSqlParser.NOLOGIN); } - public TerminalNode NOLOGIN(int i) { - return getToken(PostgreSqlParser.NOLOGIN, i); - } - public List REPLICATION() { return getTokens(PostgreSqlParser.REPLICATION); } - public TerminalNode REPLICATION(int i) { - return getToken(PostgreSqlParser.REPLICATION, i); - } - public List NOREPLICATION() { return getTokens(PostgreSqlParser.NOREPLICATION); } - public TerminalNode NOREPLICATION(int i) { - return getToken(PostgreSqlParser.NOREPLICATION, i); - } - public List BYPASSRLS() { return getTokens(PostgreSqlParser.BYPASSRLS); } - public TerminalNode BYPASSRLS(int i) { - return getToken(PostgreSqlParser.BYPASSRLS, i); - } - public List NOBYPASSRLS() { return getTokens(PostgreSqlParser.NOBYPASSRLS); } - public TerminalNode NOBYPASSRLS(int i) { - return getToken(PostgreSqlParser.NOBYPASSRLS, i); - } - public List CONNECTION() { return getTokens(PostgreSqlParser.CONNECTION); } - public TerminalNode CONNECTION(int i) { - return getToken(PostgreSqlParser.CONNECTION, i); - } - public List LIMIT() { return getTokens(PostgreSqlParser.LIMIT); } - public TerminalNode LIMIT(int i) { - return getToken(PostgreSqlParser.LIMIT, i); - } - public List parameterOrIntegerLiteral() { - return getRuleContexts(ParameterOrIntegerLiteralContext.class); - } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral(int i) { - return getRuleContext(ParameterOrIntegerLiteralContext.class,i); - } - public List PASSWORD() { return getTokens(PostgreSqlParser.PASSWORD); } - public TerminalNode PASSWORD(int i) { - return getToken(PostgreSqlParser.PASSWORD, i); - } - public List VALID() { return getTokens(PostgreSqlParser.VALID); } - public TerminalNode VALID(int i) { - return getToken(PostgreSqlParser.VALID, i); - } - public List UNTIL() { return getTokens(PostgreSqlParser.UNTIL); } - public TerminalNode UNTIL(int i) { - return getToken(PostgreSqlParser.UNTIL, i); - } - public List SINGLEQ_STRING_LITERAL() { return getTokens(PostgreSqlParser.SINGLEQ_STRING_LITERAL); } - public TerminalNode SINGLEQ_STRING_LITERAL(int i) { - return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, i); - } - public List IN() { return getTokens(PostgreSqlParser.IN); } - public TerminalNode IN(int i) { - return getToken(PostgreSqlParser.IN, i); - } - public List name_list() { - return getRuleContexts(Name_listContext.class); - } - public Name_listContext name_list(int i) { - return getRuleContext(Name_listContext.class,i); - } - public List GROUP() { return getTokens(PostgreSqlParser.GROUP); } - public TerminalNode GROUP(int i) { - return getToken(PostgreSqlParser.GROUP, i); - } - public List ADMIN() { return getTokens(PostgreSqlParser.ADMIN); } - public TerminalNode ADMIN(int i) { - return getToken(PostgreSqlParser.ADMIN, i); - } - public List USER() { return getTokens(PostgreSqlParser.USER); } - public TerminalNode USER(int i) { - return getToken(PostgreSqlParser.USER, i); - } - public List SYSID() { return getTokens(PostgreSqlParser.SYSID); } - public TerminalNode SYSID(int i) { - return getToken(PostgreSqlParser.SYSID, i); - } - public List INTEGER_LITERAL() { return getTokens(PostgreSqlParser.INTEGER_LITERAL); } - public TerminalNode INTEGER_LITERAL(int i) { - return getToken(PostgreSqlParser.INTEGER_LITERAL, i); - } - public List NULL() { return getTokens(PostgreSqlParser.NULL); } - public TerminalNode NULL(int i) { - return getToken(PostgreSqlParser.NULL, i); - } - public List ENCRYPTED() { return getTokens(PostgreSqlParser.ENCRYPTED); } - public TerminalNode ENCRYPTED(int i) { - return getToken(PostgreSqlParser.ENCRYPTED, i); - } - public Create_role_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_role_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_role_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_role_stmt(this); - } - } - - public final Create_role_stmtContext create_role_stmt() throws RecognitionException { - Create_role_stmtContext _localctx = new Create_role_stmtContext(_ctx, getState()); - enterRule(_localctx, 162, RULE_create_role_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2812); - match(CREATE); - setState(2813); - match(ROLE); - setState(2814); - ((Create_role_stmtContext)_localctx).role = role_name(); - setState(2861); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ADMIN || _la==CONNECTION || _la==CREATEDB || _la==ENCRYPTED || _la==IN || _la==NOCREATEDB || _la==PASSWORD || _la==ROLE || _la==SYSID || _la==USER || ((((_la - 629)) & ~0x3f) == 0 && ((1L << (_la - 629)) & 1099243716609L) != 0)) { - { - setState(2816); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(2815); - match(WITH); - } - } - - setState(2857); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - setState(2857); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,246,_ctx) ) { - case 1: - { - setState(2818); - match(SUPERUSER); - } - break; - case 2: - { - setState(2819); - match(NOSUPERUSER); - } - break; - case 3: - { - setState(2820); - match(CREATEDB); - } - break; - case 4: - { - setState(2821); - match(NOCREATEDB); - } - break; - case 5: - { - setState(2822); - match(CREATEROLE); - } - break; - case 6: - { - setState(2823); - match(NOCREATEROLE); - } - break; - case 7: - { - setState(2824); - match(INHERIT); - } - break; - case 8: - { - setState(2825); - match(NOINHERIT); - } - break; - case 9: - { - setState(2826); - match(LOGIN); - } - break; - case 10: - { - setState(2827); - match(NOLOGIN); - } - break; - case 11: - { - setState(2828); - match(REPLICATION); - } - break; - case 12: - { - setState(2829); - match(NOREPLICATION); - } - break; - case 13: - { - setState(2830); - match(BYPASSRLS); - } - break; - case 14: - { - setState(2831); - match(NOBYPASSRLS); - } - break; - case 15: - { - setState(2832); - match(CONNECTION); - setState(2833); - match(LIMIT); - setState(2834); - parameterOrIntegerLiteral(); - } - break; - case 16: - { - setState(2836); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ENCRYPTED) { - { - setState(2835); - match(ENCRYPTED); - } - } - - setState(2838); - match(PASSWORD); - setState(2839); - _la = _input.LA(1); - if ( !(_la==NULL || _la==SINGLEQ_STRING_LITERAL) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - case 17: - { - setState(2840); - match(VALID); - setState(2841); - match(UNTIL); - setState(2842); - match(SINGLEQ_STRING_LITERAL); - } - break; - case 18: - { - setState(2843); - match(IN); - setState(2844); - match(ROLE); - setState(2845); - name_list(); - } - break; - case 19: - { - setState(2846); - match(IN); - setState(2847); - match(GROUP); - setState(2848); - name_list(); - } - break; - case 20: - { - setState(2849); - match(ROLE); - setState(2850); - name_list(); - } - break; - case 21: - { - setState(2851); - match(ADMIN); - setState(2852); - name_list(); - } - break; - case 22: - { - setState(2853); - match(USER); - setState(2854); - name_list(); - } - break; - case 23: - { - setState(2855); - match(SYSID); - setState(2856); - match(INTEGER_LITERAL); - } - break; - } - } - setState(2859); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==ADMIN || _la==CONNECTION || _la==CREATEDB || _la==ENCRYPTED || _la==IN || _la==NOCREATEDB || _la==PASSWORD || _la==ROLE || _la==SYSID || _la==USER || ((((_la - 629)) & ~0x3f) == 0 && ((1L << (_la - 629)) & 1099243192321L) != 0) ); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_rule_eventContext extends ParserRuleContext { - public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } - public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public TerminalNode DELETE() { return getToken(PostgreSqlParser.DELETE, 0); } - public Create_rule_eventContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_rule_event; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_rule_event(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_rule_event(this); - } - } - - public final Create_rule_eventContext create_rule_event() throws RecognitionException { - Create_rule_eventContext _localctx = new Create_rule_eventContext(_ctx, getState()); - enterRule(_localctx, 164, RULE_create_rule_event); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2863); - _la = _input.LA(1); - if ( !(_la==DELETE || _la==INSERT || _la==SELECT || _la==UPDATE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_rule_stmtContext extends ParserRuleContext { - public Name_Context name; - public Create_rule_eventContext event; - public IdentifierContext tableName; - public IdentifierContext command; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode DO() { return getToken(PostgreSqlParser.DO, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public Create_rule_eventContext create_rule_event() { - return getRuleContext(Create_rule_eventContext.class,0); - } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode NOTHING() { return getToken(PostgreSqlParser.NOTHING, 0); } - public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } - public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } - public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } - public PredicateContext predicate() { - return getRuleContext(PredicateContext.class,0); - } - public TerminalNode ALSO() { return getToken(PostgreSqlParser.ALSO, 0); } - public TerminalNode INSTEAD() { return getToken(PostgreSqlParser.INSTEAD, 0); } - public Create_rule_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_rule_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_rule_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_rule_stmt(this); - } - } - - public final Create_rule_stmtContext create_rule_stmt() throws RecognitionException { - Create_rule_stmtContext _localctx = new Create_rule_stmtContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_create_rule_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2865); - match(CREATE); - setState(2868); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OR) { - { - setState(2866); - match(OR); - setState(2867); - match(REPLACE); - } - } - - setState(2870); - match(RULE); - setState(2871); - ((Create_rule_stmtContext)_localctx).name = name_(); - setState(2872); - match(AS); - setState(2873); - match(ON); - setState(2874); - ((Create_rule_stmtContext)_localctx).event = create_rule_event(); - setState(2875); - match(TO); - setState(2876); - ((Create_rule_stmtContext)_localctx).tableName = identifier(0); - setState(2879); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(2877); - match(WHERE); - setState(2878); - predicate(0); - } - } - - setState(2881); - match(DO); - setState(2883); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,251,_ctx) ) { - case 1: - { - setState(2882); - _la = _input.LA(1); - if ( !(_la==ALSO || _la==INSTEAD) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(2887); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) { - case 1: - { - setState(2885); - match(NOTHING); - } - break; - case 2: - { - setState(2886); - ((Create_rule_stmtContext)_localctx).command = identifier(0); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_schema_stmtContext extends ParserRuleContext { - public IdentifierContext schema_name; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode AUTHORIZATION() { return getToken(PostgreSqlParser.AUTHORIZATION, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public Todo_fill_inContext todo_fill_in() { - return getRuleContext(Todo_fill_inContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Create_schema_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_schema_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_schema_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_schema_stmt(this); - } - } - - public final Create_schema_stmtContext create_schema_stmt() throws RecognitionException { - Create_schema_stmtContext _localctx = new Create_schema_stmtContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_create_schema_stmt); - int _la; - try { - setState(2923); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,257,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - { - setState(2889); - match(CREATE); - setState(2890); - match(SCHEMA); - setState(2891); - ((Create_schema_stmtContext)_localctx).schema_name = identifier(0); - setState(2894); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,253,_ctx) ) { - case 1: - { - setState(2892); - match(AUTHORIZATION); - setState(2893); - role_name(); - } - break; - } - setState(2897); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,254,_ctx) ) { - case 1: - { - setState(2896); - todo_fill_in(); - } - break; - } - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - { - setState(2899); - match(CREATE); - setState(2900); - match(SCHEMA); - setState(2901); - match(AUTHORIZATION); - setState(2902); - role_name(); - setState(2904); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,255,_ctx) ) { - case 1: - { - setState(2903); - todo_fill_in(); - } - break; - } - } - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - { - setState(2906); - match(CREATE); - setState(2907); - match(SCHEMA); - setState(2908); - match(IF); - setState(2909); - match(NOT); - setState(2910); - match(EXISTS); - setState(2911); - ((Create_schema_stmtContext)_localctx).schema_name = identifier(0); - setState(2914); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AUTHORIZATION) { - { - setState(2912); - match(AUTHORIZATION); - setState(2913); - role_name(); - } - } - - } - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - { - setState(2916); - match(CREATE); - setState(2917); - match(SCHEMA); - setState(2918); - match(IF); - setState(2919); - match(NOT); - setState(2920); - match(EXISTS); - setState(2921); - match(AUTHORIZATION); - setState(2922); - role_name(); - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_sequence_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public ParameterOrIntegerLiteralContext increment; - public ParameterOrIntegerLiteralContext minvalue; - public ParameterOrIntegerLiteralContext maxvalue; - public ParameterOrIntegerLiteralContext start; - public ParameterOrIntegerLiteralContext cache; - public IdentifierContext table_name; - public IdentifierContext column_name_; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode INCREMENT() { return getToken(PostgreSqlParser.INCREMENT, 0); } - public TerminalNode MINVALUE() { return getToken(PostgreSqlParser.MINVALUE, 0); } - public List NO() { return getTokens(PostgreSqlParser.NO); } - public TerminalNode NO(int i) { - return getToken(PostgreSqlParser.NO, i); - } - public TerminalNode MAXVALUE() { return getToken(PostgreSqlParser.MAXVALUE, 0); } - public TerminalNode START() { return getToken(PostgreSqlParser.START, 0); } - public TerminalNode CACHE() { return getToken(PostgreSqlParser.CACHE, 0); } - public TerminalNode CYCLE() { return getToken(PostgreSqlParser.CYCLE, 0); } - public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } - public List BY() { return getTokens(PostgreSqlParser.BY); } - public TerminalNode BY(int i) { - return getToken(PostgreSqlParser.BY, i); - } - public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } - public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } - public List parameterOrIntegerLiteral() { - return getRuleContexts(ParameterOrIntegerLiteralContext.class); - } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral(int i) { - return getRuleContext(ParameterOrIntegerLiteralContext.class,i); - } - public TerminalNode NONE() { return getToken(PostgreSqlParser.NONE, 0); } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode DOT() { return getToken(PostgreSqlParser.DOT, 0); } - public Create_sequence_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_sequence_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_sequence_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_sequence_stmt(this); - } - } - - public final Create_sequence_stmtContext create_sequence_stmt() throws RecognitionException { - Create_sequence_stmtContext _localctx = new Create_sequence_stmtContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_create_sequence_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2925); - match(CREATE); - setState(2927); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TEMP || _la==TEMPORARY) { - { - setState(2926); - _la = _input.LA(1); - if ( !(_la==TEMP || _la==TEMPORARY) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(2929); - match(SEQUENCE); - setState(2933); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(2930); - match(IF); - setState(2931); - match(NOT); - setState(2932); - match(EXISTS); - } - } - - setState(2935); - ((Create_sequence_stmtContext)_localctx).name = identifier(0); - setState(2941); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INCREMENT) { - { - setState(2936); - match(INCREMENT); - setState(2938); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==BY) { - { - setState(2937); - match(BY); - } - } - - setState(2940); - ((Create_sequence_stmtContext)_localctx).increment = parameterOrIntegerLiteral(); - } - } - - setState(2947); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) { - case 1: - { - setState(2943); - match(MINVALUE); - setState(2944); - ((Create_sequence_stmtContext)_localctx).minvalue = parameterOrIntegerLiteral(); - } - break; - case 2: - { - setState(2945); - match(NO); - setState(2946); - match(MINVALUE); - } - break; - } - setState(2953); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,263,_ctx) ) { - case 1: - { - setState(2949); - match(MAXVALUE); - setState(2950); - ((Create_sequence_stmtContext)_localctx).maxvalue = parameterOrIntegerLiteral(); - } - break; - case 2: - { - setState(2951); - match(NO); - setState(2952); - match(MAXVALUE); - } - break; - } - setState(2960); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==START) { - { - setState(2955); - match(START); - setState(2957); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(2956); - match(WITH); - } - } - - setState(2959); - ((Create_sequence_stmtContext)_localctx).start = parameterOrIntegerLiteral(); - } - } - - setState(2964); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CACHE) { - { - setState(2962); - match(CACHE); - setState(2963); - ((Create_sequence_stmtContext)_localctx).cache = parameterOrIntegerLiteral(); - } - } - - setState(2970); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CYCLE || _la==NO) { - { - setState(2967); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NO) { - { - setState(2966); - match(NO); - } - } - - setState(2969); - match(CYCLE); - } - } - - setState(2981); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OWNED) { - { - setState(2972); - match(OWNED); - setState(2973); - match(BY); - setState(2979); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,269,_ctx) ) { - case 1: - { - { - setState(2974); - ((Create_sequence_stmtContext)_localctx).table_name = identifier(0); - setState(2975); - match(DOT); - setState(2976); - ((Create_sequence_stmtContext)_localctx).column_name_ = identifier(0); - } - } - break; - case 2: - { - setState(2978); - match(NONE); - } - break; - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_server_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_server_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_server_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_server_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_server_stmt(this); - } - } - - public final Create_server_stmtContext create_server_stmt() throws RecognitionException { - Create_server_stmtContext _localctx = new Create_server_stmtContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_create_server_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2983); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_statistics_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_statistics_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_statistics_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_statistics_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_statistics_stmt(this); - } - } - - public final Create_statistics_stmtContext create_statistics_stmt() throws RecognitionException { - Create_statistics_stmtContext _localctx = new Create_statistics_stmtContext(_ctx, getState()); - enterRule(_localctx, 174, RULE_create_statistics_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2985); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_subscription_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_subscription_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_subscription_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_subscription_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_subscription_stmt(this); - } - } - - public final Create_subscription_stmtContext create_subscription_stmt() throws RecognitionException { - Create_subscription_stmtContext _localctx = new Create_subscription_stmtContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_create_subscription_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2987); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_table_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_table_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_table_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_table_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_table_stmt(this); - } - } - - public final Create_table_stmtContext create_table_stmt() throws RecognitionException { - Create_table_stmtContext _localctx = new Create_table_stmtContext(_ctx, getState()); - enterRule(_localctx, 178, RULE_create_table_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2989); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_table_as_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_table_as_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_table_as_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_table_as_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_table_as_stmt(this); - } - } - - public final Create_table_as_stmtContext create_table_as_stmt() throws RecognitionException { - Create_table_as_stmtContext _localctx = new Create_table_as_stmtContext(_ctx, getState()); - enterRule(_localctx, 180, RULE_create_table_as_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2991); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_tablespace_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_tablespace_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_tablespace_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_tablespace_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_tablespace_stmt(this); - } - } - - public final Create_tablespace_stmtContext create_tablespace_stmt() throws RecognitionException { - Create_tablespace_stmtContext _localctx = new Create_tablespace_stmtContext(_ctx, getState()); - enterRule(_localctx, 182, RULE_create_tablespace_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2993); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_text_search_config_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_text_search_config_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_text_search_config_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_text_search_config_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_text_search_config_stmt(this); - } - } - - public final Create_text_search_config_stmtContext create_text_search_config_stmt() throws RecognitionException { - Create_text_search_config_stmtContext _localctx = new Create_text_search_config_stmtContext(_ctx, getState()); - enterRule(_localctx, 184, RULE_create_text_search_config_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2995); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_text_search_dict_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_text_search_dict_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_text_search_dict_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_text_search_dict_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_text_search_dict_stmt(this); - } - } - - public final Create_text_search_dict_stmtContext create_text_search_dict_stmt() throws RecognitionException { - Create_text_search_dict_stmtContext _localctx = new Create_text_search_dict_stmtContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_create_text_search_dict_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2997); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_text_search_parser_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_text_search_parser_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_text_search_parser_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_text_search_parser_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_text_search_parser_stmt(this); - } - } - - public final Create_text_search_parser_stmtContext create_text_search_parser_stmt() throws RecognitionException { - Create_text_search_parser_stmtContext _localctx = new Create_text_search_parser_stmtContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_create_text_search_parser_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(2999); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_text_search_template_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_text_search_template_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_text_search_template_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_text_search_template_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_text_search_template_stmt(this); - } - } - - public final Create_text_search_template_stmtContext create_text_search_template_stmt() throws RecognitionException { - Create_text_search_template_stmtContext _localctx = new Create_text_search_template_stmtContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_create_text_search_template_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3001); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_transform_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_transform_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_transform_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_transform_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_transform_stmt(this); - } - } - - public final Create_transform_stmtContext create_transform_stmt() throws RecognitionException { - Create_transform_stmtContext _localctx = new Create_transform_stmtContext(_ctx, getState()); - enterRule(_localctx, 192, RULE_create_transform_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3003); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_trigger_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_trigger_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_trigger_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_trigger_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_trigger_stmt(this); - } - } - - public final Create_trigger_stmtContext create_trigger_stmt() throws RecognitionException { - Create_trigger_stmtContext _localctx = new Create_trigger_stmtContext(_ctx, getState()); - enterRule(_localctx, 194, RULE_create_trigger_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3005); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_type_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_type_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_type_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_type_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_type_stmt(this); - } - } - - public final Create_type_stmtContext create_type_stmt() throws RecognitionException { - Create_type_stmtContext _localctx = new Create_type_stmtContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_create_type_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3007); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_user_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_user_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_user_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_user_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_user_stmt(this); - } - } - - public final Create_user_stmtContext create_user_stmt() throws RecognitionException { - Create_user_stmtContext _localctx = new Create_user_stmtContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_create_user_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3009); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_user_mapping_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Create_user_mapping_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_user_mapping_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_user_mapping_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_user_mapping_stmt(this); - } - } - - public final Create_user_mapping_stmtContext create_user_mapping_stmt() throws RecognitionException { - Create_user_mapping_stmtContext _localctx = new Create_user_mapping_stmtContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_create_user_mapping_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3011); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Create_view_stmtContext extends ParserRuleContext { - public Name_Context name; - public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); - } - public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } - public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } - public TerminalNode RECURSIVE() { return getToken(PostgreSqlParser.RECURSIVE, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public List WITH() { return getTokens(PostgreSqlParser.WITH); } - public TerminalNode WITH(int i) { - return getToken(PostgreSqlParser.WITH, i); - } - public Option_listContext option_list() { - return getRuleContext(Option_listContext.class,0); - } - public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } - public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } - public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } - public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } - public TerminalNode CASCADED() { return getToken(PostgreSqlParser.CASCADED, 0); } - public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } - public Create_view_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_create_view_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_view_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_view_stmt(this); - } - } - - public final Create_view_stmtContext create_view_stmt() throws RecognitionException { - Create_view_stmtContext _localctx = new Create_view_stmtContext(_ctx, getState()); - enterRule(_localctx, 202, RULE_create_view_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3013); - match(CREATE); - setState(3016); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OR) { - { - setState(3014); - match(OR); - setState(3015); - match(REPLACE); - } - } - - setState(3019); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TEMP || _la==TEMPORARY) { - { - setState(3018); - _la = _input.LA(1); - if ( !(_la==TEMP || _la==TEMPORARY) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(3022); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==RECURSIVE) { - { - setState(3021); - match(RECURSIVE); - } - } - - setState(3024); - match(VIEW); - setState(3025); - ((Create_view_stmtContext)_localctx).name = name_(); - setState(3030); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(3026); - match(OPEN_PAREN); - setState(3027); - name_list(); - setState(3028); - match(CLOSE_PAREN); - } - } - - setState(3037); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(3032); - match(WITH); - setState(3033); - match(OPEN_PAREN); - setState(3034); - option_list(); - setState(3035); - match(CLOSE_PAREN); - } - } - - setState(3039); - match(AS); - setState(3042); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,276,_ctx) ) { - case 1: - { - setState(3040); - select_stmt(); - } - break; - case 2: - { - setState(3041); - values_stmt(); - } - break; - } - setState(3050); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(3044); - match(WITH); - setState(3046); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADED || _la==LOCAL) { - { - setState(3045); - _la = _input.LA(1); - if ( !(_la==CASCADED || _la==LOCAL) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(3048); - match(CHECK); - setState(3049); - match(OPTION); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Deallocate_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Deallocate_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_deallocate_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDeallocate_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDeallocate_stmt(this); - } - } - - public final Deallocate_stmtContext deallocate_stmt() throws RecognitionException { - Deallocate_stmtContext _localctx = new Deallocate_stmtContext(_ctx, getState()); - enterRule(_localctx, 204, RULE_deallocate_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3052); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Declare_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Declare_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_declare_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDeclare_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDeclare_stmt(this); - } - } - - public final Declare_stmtContext declare_stmt() throws RecognitionException { - Declare_stmtContext _localctx = new Declare_stmtContext(_ctx, getState()); - enterRule(_localctx, 206, RULE_declare_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3054); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Delete_stmtContext extends ParserRuleContext { - public IdentifierContext cursor_name_; - public TerminalNode DELETE() { return getToken(PostgreSqlParser.DELETE, 0); } - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public With_clauseContext with_clause() { - return getRuleContext(With_clauseContext.class,0); - } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public AliasContext alias() { - return getRuleContext(AliasContext.class,0); - } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public Where_clauseContext where_clause() { - return getRuleContext(Where_clauseContext.class,0); - } - public Returning_clauseContext returning_clause() { - return getRuleContext(Returning_clauseContext.class,0); - } - public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } - public TerminalNode CURRENT() { return getToken(PostgreSqlParser.CURRENT, 0); } - public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Delete_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_delete_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDelete_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDelete_stmt(this); - } - } - - public final Delete_stmtContext delete_stmt() throws RecognitionException { - Delete_stmtContext _localctx = new Delete_stmtContext(_ctx, getState()); - enterRule(_localctx, 208, RULE_delete_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3057); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(3056); - with_clause(); - } - } - - setState(3059); - match(DELETE); - setState(3060); - match(FROM); - setState(3062); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(3061); - match(ONLY); - } - } - - setState(3064); - table_name_(); - setState(3066); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==STAR) { - { - setState(3065); - match(STAR); - } - } - - setState(3072); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217925918706L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245456777353L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206585526350118915L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3120954820635131899L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3170536334544601087L) != 0)) { - { - setState(3069); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(3068); - match(AS); - } - } - - setState(3071); - alias(); - } - } - - setState(3076); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==USING) { - { - setState(3074); - match(USING); - setState(3075); - identifier_list(); - } - } - - setState(3083); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,285,_ctx) ) { - case 1: - { - setState(3078); - where_clause(); - } - break; - case 2: - { - { - setState(3079); - match(WHERE); - setState(3080); - match(CURRENT); - setState(3081); - match(OF); - setState(3082); - ((Delete_stmtContext)_localctx).cursor_name_ = identifier(0); - } - } - break; - } - setState(3086); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==RETURNING) { - { - setState(3085); - returning_clause(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Discard_stmtContext extends ParserRuleContext { - public TerminalNode DISCARD() { return getToken(PostgreSqlParser.DISCARD, 0); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public TerminalNode PLANS() { return getToken(PostgreSqlParser.PLANS, 0); } - public TerminalNode SEQUENCES() { return getToken(PostgreSqlParser.SEQUENCES, 0); } - public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } - public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } - public Discard_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_discard_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDiscard_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDiscard_stmt(this); - } - } - - public final Discard_stmtContext discard_stmt() throws RecognitionException { - Discard_stmtContext _localctx = new Discard_stmtContext(_ctx, getState()); - enterRule(_localctx, 210, RULE_discard_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3088); - match(DISCARD); - setState(3089); - _la = _input.LA(1); - if ( !(_la==ALL || _la==PLANS || ((((_la - 514)) & ~0x3f) == 0 && ((1L << (_la - 514)) & 720575940379279361L) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_stmtContext extends ParserRuleContext { - public Drop_access_method_stmtContext drop_access_method_stmt() { - return getRuleContext(Drop_access_method_stmtContext.class,0); - } - public Drop_aggregate_stmtContext drop_aggregate_stmt() { - return getRuleContext(Drop_aggregate_stmtContext.class,0); - } - public Drop_cast_stmtContext drop_cast_stmt() { - return getRuleContext(Drop_cast_stmtContext.class,0); - } - public Drop_collation_stmtContext drop_collation_stmt() { - return getRuleContext(Drop_collation_stmtContext.class,0); - } - public Drop_conversion_stmtContext drop_conversion_stmt() { - return getRuleContext(Drop_conversion_stmtContext.class,0); - } - public Drop_database_stmtContext drop_database_stmt() { - return getRuleContext(Drop_database_stmtContext.class,0); - } - public Drop_domain_stmtContext drop_domain_stmt() { - return getRuleContext(Drop_domain_stmtContext.class,0); - } - public Drop_event_trigger_stmtContext drop_event_trigger_stmt() { - return getRuleContext(Drop_event_trigger_stmtContext.class,0); - } - public Drop_extension_stmtContext drop_extension_stmt() { - return getRuleContext(Drop_extension_stmtContext.class,0); - } - public Drop_foreign_data_wrapper_stmtContext drop_foreign_data_wrapper_stmt() { - return getRuleContext(Drop_foreign_data_wrapper_stmtContext.class,0); - } - public Drop_foreign_table_stmtContext drop_foreign_table_stmt() { - return getRuleContext(Drop_foreign_table_stmtContext.class,0); - } - public Drop_function_stmtContext drop_function_stmt() { - return getRuleContext(Drop_function_stmtContext.class,0); - } - public Drop_group_stmtContext drop_group_stmt() { - return getRuleContext(Drop_group_stmtContext.class,0); - } - public Drop_index_stmtContext drop_index_stmt() { - return getRuleContext(Drop_index_stmtContext.class,0); - } - public Drop_language_stmtContext drop_language_stmt() { - return getRuleContext(Drop_language_stmtContext.class,0); - } - public Drop_materialized_view_stmtContext drop_materialized_view_stmt() { - return getRuleContext(Drop_materialized_view_stmtContext.class,0); - } - public Drop_operator_stmtContext drop_operator_stmt() { - return getRuleContext(Drop_operator_stmtContext.class,0); - } - public Drop_operator_class_stmtContext drop_operator_class_stmt() { - return getRuleContext(Drop_operator_class_stmtContext.class,0); - } - public Drop_operator_family_stmtContext drop_operator_family_stmt() { - return getRuleContext(Drop_operator_family_stmtContext.class,0); - } - public Drop_owned_stmtContext drop_owned_stmt() { - return getRuleContext(Drop_owned_stmtContext.class,0); - } - public Drop_policy_stmtContext drop_policy_stmt() { - return getRuleContext(Drop_policy_stmtContext.class,0); - } - public Drop_publication_stmtContext drop_publication_stmt() { - return getRuleContext(Drop_publication_stmtContext.class,0); - } - public Drop_role_stmtContext drop_role_stmt() { - return getRuleContext(Drop_role_stmtContext.class,0); - } - public Drop_rule_stmtContext drop_rule_stmt() { - return getRuleContext(Drop_rule_stmtContext.class,0); - } - public Drop_schema_stmtContext drop_schema_stmt() { - return getRuleContext(Drop_schema_stmtContext.class,0); - } - public Drop_sequence_stmtContext drop_sequence_stmt() { - return getRuleContext(Drop_sequence_stmtContext.class,0); - } - public Drop_server_stmtContext drop_server_stmt() { - return getRuleContext(Drop_server_stmtContext.class,0); - } - public Drop_statistics_stmtContext drop_statistics_stmt() { - return getRuleContext(Drop_statistics_stmtContext.class,0); - } - public Drop_subscription_stmtContext drop_subscription_stmt() { - return getRuleContext(Drop_subscription_stmtContext.class,0); - } - public Drop_table_stmtContext drop_table_stmt() { - return getRuleContext(Drop_table_stmtContext.class,0); - } - public Drop_tablespace_stmtContext drop_tablespace_stmt() { - return getRuleContext(Drop_tablespace_stmtContext.class,0); - } - public Drop_text_search_config_stmtContext drop_text_search_config_stmt() { - return getRuleContext(Drop_text_search_config_stmtContext.class,0); - } - public Drop_text_search_dict_stmtContext drop_text_search_dict_stmt() { - return getRuleContext(Drop_text_search_dict_stmtContext.class,0); - } - public Drop_text_search_parser_stmtContext drop_text_search_parser_stmt() { - return getRuleContext(Drop_text_search_parser_stmtContext.class,0); - } - public Drop_text_search_template_stmtContext drop_text_search_template_stmt() { - return getRuleContext(Drop_text_search_template_stmtContext.class,0); - } - public Drop_transform_stmtContext drop_transform_stmt() { - return getRuleContext(Drop_transform_stmtContext.class,0); - } - public Drop_trigger_stmtContext drop_trigger_stmt() { - return getRuleContext(Drop_trigger_stmtContext.class,0); - } - public Drop_type_stmtContext drop_type_stmt() { - return getRuleContext(Drop_type_stmtContext.class,0); - } - public Drop_user_stmtContext drop_user_stmt() { - return getRuleContext(Drop_user_stmtContext.class,0); - } - public Drop_user_mapping_stmtContext drop_user_mapping_stmt() { - return getRuleContext(Drop_user_mapping_stmtContext.class,0); - } - public Drop_view_stmtContext drop_view_stmt() { - return getRuleContext(Drop_view_stmtContext.class,0); - } - public Drop_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_stmt(this); - } - } - - public final Drop_stmtContext drop_stmt() throws RecognitionException { - Drop_stmtContext _localctx = new Drop_stmtContext(_ctx, getState()); - enterRule(_localctx, 212, RULE_drop_stmt); - try { - setState(3132); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(3091); - drop_access_method_stmt(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(3092); - drop_aggregate_stmt(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(3093); - drop_cast_stmt(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(3094); - drop_collation_stmt(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(3095); - drop_conversion_stmt(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(3096); - drop_database_stmt(); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(3097); - drop_domain_stmt(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(3098); - drop_event_trigger_stmt(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(3099); - drop_extension_stmt(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(3100); - drop_foreign_data_wrapper_stmt(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(3101); - drop_foreign_table_stmt(); - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(3102); - drop_function_stmt(); - } - break; - case 13: - enterOuterAlt(_localctx, 13); - { - setState(3103); - drop_group_stmt(); - } - break; - case 14: - enterOuterAlt(_localctx, 14); - { - setState(3104); - drop_index_stmt(); - } - break; - case 15: - enterOuterAlt(_localctx, 15); - { - setState(3105); - drop_language_stmt(); - } - break; - case 16: - enterOuterAlt(_localctx, 16); - { - setState(3106); - drop_materialized_view_stmt(); - } - break; - case 17: - enterOuterAlt(_localctx, 17); - { - setState(3107); - drop_operator_stmt(); - } - break; - case 18: - enterOuterAlt(_localctx, 18); - { - setState(3108); - drop_operator_class_stmt(); - } - break; - case 19: - enterOuterAlt(_localctx, 19); - { - setState(3109); - drop_operator_family_stmt(); - } - break; - case 20: - enterOuterAlt(_localctx, 20); - { - setState(3110); - drop_owned_stmt(); - } - break; - case 21: - enterOuterAlt(_localctx, 21); - { - setState(3111); - drop_policy_stmt(); - } - break; - case 22: - enterOuterAlt(_localctx, 22); - { - setState(3112); - drop_publication_stmt(); - } - break; - case 23: - enterOuterAlt(_localctx, 23); - { - setState(3113); - drop_role_stmt(); - } - break; - case 24: - enterOuterAlt(_localctx, 24); - { - setState(3114); - drop_rule_stmt(); - } - break; - case 25: - enterOuterAlt(_localctx, 25); - { - setState(3115); - drop_schema_stmt(); - } - break; - case 26: - enterOuterAlt(_localctx, 26); - { - setState(3116); - drop_sequence_stmt(); - } - break; - case 27: - enterOuterAlt(_localctx, 27); - { - setState(3117); - drop_server_stmt(); - } - break; - case 28: - enterOuterAlt(_localctx, 28); - { - setState(3118); - drop_statistics_stmt(); - } - break; - case 29: - enterOuterAlt(_localctx, 29); - { - setState(3119); - drop_subscription_stmt(); - } - break; - case 30: - enterOuterAlt(_localctx, 30); - { - setState(3120); - drop_table_stmt(); - } - break; - case 31: - enterOuterAlt(_localctx, 31); - { - setState(3121); - drop_tablespace_stmt(); - } - break; - case 32: - enterOuterAlt(_localctx, 32); - { - setState(3122); - drop_text_search_config_stmt(); - } - break; - case 33: - enterOuterAlt(_localctx, 33); - { - setState(3123); - drop_text_search_dict_stmt(); - } - break; - case 34: - enterOuterAlt(_localctx, 34); - { - setState(3124); - drop_text_search_parser_stmt(); - } - break; - case 35: - enterOuterAlt(_localctx, 35); - { - setState(3125); - drop_text_search_template_stmt(); - } - break; - case 36: - enterOuterAlt(_localctx, 36); - { - setState(3126); - drop_transform_stmt(); - } - break; - case 37: - enterOuterAlt(_localctx, 37); - { - setState(3127); - drop_trigger_stmt(); - } - break; - case 38: - enterOuterAlt(_localctx, 38); - { - setState(3128); - drop_type_stmt(); - } - break; - case 39: - enterOuterAlt(_localctx, 39); - { - setState(3129); - drop_user_stmt(); + setState(1680); + constraintssetstmt(); } break; case 40: enterOuterAlt(_localctx, 40); { - setState(3130); - drop_user_mapping_stmt(); + setState(1681); + copystmt(); } break; case 41: enterOuterAlt(_localctx, 41); { - setState(3131); - drop_view_stmt(); + setState(1682); + createamstmt(); + } + break; + case 42: + enterOuterAlt(_localctx, 42); + { + setState(1683); + createasstmt(); + } + break; + case 43: + enterOuterAlt(_localctx, 43); + { + setState(1684); + createassertionstmt(); + } + break; + case 44: + enterOuterAlt(_localctx, 44); + { + setState(1685); + createcaststmt(); + } + break; + case 45: + enterOuterAlt(_localctx, 45); + { + setState(1686); + createconversionstmt(); + } + break; + case 46: + enterOuterAlt(_localctx, 46); + { + setState(1687); + createdomainstmt(); + } + break; + case 47: + enterOuterAlt(_localctx, 47); + { + setState(1688); + createextensionstmt(); + } + break; + case 48: + enterOuterAlt(_localctx, 48); + { + setState(1689); + createfdwstmt(); + } + break; + case 49: + enterOuterAlt(_localctx, 49); + { + setState(1690); + createforeignserverstmt(); + } + break; + case 50: + enterOuterAlt(_localctx, 50); + { + setState(1691); + createforeigntablestmt(); + } + break; + case 51: + enterOuterAlt(_localctx, 51); + { + setState(1692); + createfunctionstmt(); + } + break; + case 52: + enterOuterAlt(_localctx, 52); + { + setState(1693); + creategroupstmt(); + } + break; + case 53: + enterOuterAlt(_localctx, 53); + { + setState(1694); + creatematviewstmt(); + } + break; + case 54: + enterOuterAlt(_localctx, 54); + { + setState(1695); + createopclassstmt(); + } + break; + case 55: + enterOuterAlt(_localctx, 55); + { + setState(1696); + createopfamilystmt(); + } + break; + case 56: + enterOuterAlt(_localctx, 56); + { + setState(1697); + createpublicationstmt(); + } + break; + case 57: + enterOuterAlt(_localctx, 57); + { + setState(1698); + alteropfamilystmt(); + } + break; + case 58: + enterOuterAlt(_localctx, 58); + { + setState(1699); + createpolicystmt(); + } + break; + case 59: + enterOuterAlt(_localctx, 59); + { + setState(1700); + createplangstmt(); + } + break; + case 60: + enterOuterAlt(_localctx, 60); + { + setState(1701); + createschemastmt(); + } + break; + case 61: + enterOuterAlt(_localctx, 61); + { + setState(1702); + createseqstmt(); + } + break; + case 62: + enterOuterAlt(_localctx, 62); + { + setState(1703); + createstmt(); + } + break; + case 63: + enterOuterAlt(_localctx, 63); + { + setState(1704); + createsubscriptionstmt(); + } + break; + case 64: + enterOuterAlt(_localctx, 64); + { + setState(1705); + createstatsstmt(); + } + break; + case 65: + enterOuterAlt(_localctx, 65); + { + setState(1706); + createtablespacestmt(); + } + break; + case 66: + enterOuterAlt(_localctx, 66); + { + setState(1707); + createtransformstmt(); + } + break; + case 67: + enterOuterAlt(_localctx, 67); + { + setState(1708); + createtrigstmt(); + } + break; + case 68: + enterOuterAlt(_localctx, 68); + { + setState(1709); + createeventtrigstmt(); + } + break; + case 69: + enterOuterAlt(_localctx, 69); + { + setState(1710); + createrolestmt(); + } + break; + case 70: + enterOuterAlt(_localctx, 70); + { + setState(1711); + createuserstmt(); + } + break; + case 71: + enterOuterAlt(_localctx, 71); + { + setState(1712); + createusermappingstmt(); + } + break; + case 72: + enterOuterAlt(_localctx, 72); + { + setState(1713); + createdbstmt(); + } + break; + case 73: + enterOuterAlt(_localctx, 73); + { + setState(1714); + deallocatestmt(); + } + break; + case 74: + enterOuterAlt(_localctx, 74); + { + setState(1715); + declarecursorstmt(); + } + break; + case 75: + enterOuterAlt(_localctx, 75); + { + setState(1716); + definestmt(); + } + break; + case 76: + enterOuterAlt(_localctx, 76); + { + setState(1717); + deletestmt(); + } + break; + case 77: + enterOuterAlt(_localctx, 77); + { + setState(1718); + discardstmt(); + } + break; + case 78: + enterOuterAlt(_localctx, 78); + { + setState(1719); + dostmt(); + } + break; + case 79: + enterOuterAlt(_localctx, 79); + { + setState(1720); + dropcaststmt(); + } + break; + case 80: + enterOuterAlt(_localctx, 80); + { + setState(1721); + dropopclassstmt(); + } + break; + case 81: + enterOuterAlt(_localctx, 81); + { + setState(1722); + dropopfamilystmt(); + } + break; + case 82: + enterOuterAlt(_localctx, 82); + { + setState(1723); + dropownedstmt(); + } + break; + case 83: + enterOuterAlt(_localctx, 83); + { + setState(1724); + dropstmt(); + } + break; + case 84: + enterOuterAlt(_localctx, 84); + { + setState(1725); + dropsubscriptionstmt(); + } + break; + case 85: + enterOuterAlt(_localctx, 85); + { + setState(1726); + droptablespacestmt(); + } + break; + case 86: + enterOuterAlt(_localctx, 86); + { + setState(1727); + droptransformstmt(); + } + break; + case 87: + enterOuterAlt(_localctx, 87); + { + setState(1728); + droprolestmt(); + } + break; + case 88: + enterOuterAlt(_localctx, 88); + { + setState(1729); + dropusermappingstmt(); + } + break; + case 89: + enterOuterAlt(_localctx, 89); + { + setState(1730); + dropdbstmt(); + } + break; + case 90: + enterOuterAlt(_localctx, 90); + { + setState(1731); + executestmt(); + } + break; + case 91: + enterOuterAlt(_localctx, 91); + { + setState(1732); + explainstmt(); + } + break; + case 92: + enterOuterAlt(_localctx, 92); + { + setState(1733); + fetchstmt(); + } + break; + case 93: + enterOuterAlt(_localctx, 93); + { + setState(1734); + grantstmt(); + } + break; + case 94: + enterOuterAlt(_localctx, 94); + { + setState(1735); + grantrolestmt(); + } + break; + case 95: + enterOuterAlt(_localctx, 95); + { + setState(1736); + importforeignschemastmt(); + } + break; + case 96: + enterOuterAlt(_localctx, 96); + { + setState(1737); + indexstmt(); + } + break; + case 97: + enterOuterAlt(_localctx, 97); + { + setState(1738); + insertstmt(); + } + break; + case 98: + enterOuterAlt(_localctx, 98); + { + setState(1739); + mergestmt(); + } + break; + case 99: + enterOuterAlt(_localctx, 99); + { + setState(1740); + listenstmt(); + } + break; + case 100: + enterOuterAlt(_localctx, 100); + { + setState(1741); + refreshmatviewstmt(); + } + break; + case 101: + enterOuterAlt(_localctx, 101); + { + setState(1742); + loadstmt(); + } + break; + case 102: + enterOuterAlt(_localctx, 102); + { + setState(1743); + lockstmt(); + } + break; + case 103: + enterOuterAlt(_localctx, 103); + { + setState(1744); + notifystmt(); + } + break; + case 104: + enterOuterAlt(_localctx, 104); + { + setState(1745); + preparestmt(); + } + break; + case 105: + enterOuterAlt(_localctx, 105); + { + setState(1746); + reassignownedstmt(); + } + break; + case 106: + enterOuterAlt(_localctx, 106); + { + setState(1747); + reindexstmt(); + } + break; + case 107: + enterOuterAlt(_localctx, 107); + { + setState(1748); + removeaggrstmt(); + } + break; + case 108: + enterOuterAlt(_localctx, 108); + { + setState(1749); + removefuncstmt(); + } + break; + case 109: + enterOuterAlt(_localctx, 109); + { + setState(1750); + removeoperstmt(); + } + break; + case 110: + enterOuterAlt(_localctx, 110); + { + setState(1751); + renamestmt(); + } + break; + case 111: + enterOuterAlt(_localctx, 111); + { + setState(1752); + revokestmt(); + } + break; + case 112: + enterOuterAlt(_localctx, 112); + { + setState(1753); + revokerolestmt(); + } + break; + case 113: + enterOuterAlt(_localctx, 113); + { + setState(1754); + rulestmt(); + } + break; + case 114: + enterOuterAlt(_localctx, 114); + { + setState(1755); + seclabelstmt(); + } + break; + case 115: + enterOuterAlt(_localctx, 115); + { + setState(1756); + selectstmt(); + } + break; + case 116: + enterOuterAlt(_localctx, 116); + { + setState(1757); + transactionstmt(); + } + break; + case 117: + enterOuterAlt(_localctx, 117); + { + setState(1758); + truncatestmt(); + } + break; + case 118: + enterOuterAlt(_localctx, 118); + { + setState(1759); + unlistenstmt(); + } + break; + case 119: + enterOuterAlt(_localctx, 119); + { + setState(1760); + updatestmt(); + } + break; + case 120: + enterOuterAlt(_localctx, 120); + { + setState(1761); + vacuumstmt(); + } + break; + case 121: + enterOuterAlt(_localctx, 121); + { + setState(1762); + variableresetstmt(); + } + break; + case 122: + enterOuterAlt(_localctx, 122); + { + setState(1763); + variablesetstmt(); + } + break; + case 123: + enterOuterAlt(_localctx, 123); + { + setState(1764); + variableshowstmt(); + } + break; + case 124: + enterOuterAlt(_localctx, 124); + { + setState(1765); + viewstmt(); + } + break; + case 125: + enterOuterAlt(_localctx, 125); + { + setState(1766); + plsqlconsolecommand(); } break; } @@ -21490,74 +2371,39 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Drop_access_method_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode ACCESS() { return getToken(PostgreSqlParser.ACCESS, 0); } - public TerminalNode METHOD() { return getToken(PostgreSqlParser.METHOD, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_access_method_stmtContext(ParserRuleContext parent, int invokingState) { + public static class PlsqlconsolecommandContext extends ParserRuleContext { + public TerminalNode MetaCommand() { return getToken(PostgreSqlParser.MetaCommand, 0); } + public TerminalNode EndMetaCommand() { return getToken(PostgreSqlParser.EndMetaCommand, 0); } + public PlsqlconsolecommandContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_drop_access_method_stmt; } + @Override public int getRuleIndex() { return RULE_plsqlconsolecommand; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_access_method_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPlsqlconsolecommand(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_access_method_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPlsqlconsolecommand(this); } } - public final Drop_access_method_stmtContext drop_access_method_stmt() throws RecognitionException { - Drop_access_method_stmtContext _localctx = new Drop_access_method_stmtContext(_ctx, getState()); - enterRule(_localctx, 214, RULE_drop_access_method_stmt); + public final PlsqlconsolecommandContext plsqlconsolecommand() throws RecognitionException { + PlsqlconsolecommandContext _localctx = new PlsqlconsolecommandContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_plsqlconsolecommand); int _la; try { enterOuterAlt(_localctx, 1); { - setState(3134); - match(DROP); - setState(3135); - match(ACCESS); - setState(3136); - match(METHOD); - setState(3139); + setState(1769); + match(MetaCommand); + setState(1771); _errHandler.sync(this); _la = _input.LA(1); - if (_la==IF) { + if (_la==EndMetaCommand) { { - setState(3137); - match(IF); - setState(3138); - match(EXISTS); - } - } - - setState(3141); - ((Drop_access_method_stmtContext)_localctx).name = identifier(0); - setState(3143); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3142); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } + setState(1770); + match(EndMetaCommand); } } @@ -21575,65 +2421,35 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Drop_aggregate_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Aggregate_signatureContext aggregate_signature() { - return getRuleContext(Aggregate_signatureContext.class,0); + public static class CallstmtContext extends ParserRuleContext { + public TerminalNode CALL() { return getToken(PostgreSqlParser.CALL, 0); } + public Func_applicationContext func_application() { + return getRuleContext(Func_applicationContext.class,0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Drop_aggregate_stmtContext(ParserRuleContext parent, int invokingState) { + public CallstmtContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_drop_aggregate_stmt; } + @Override public int getRuleIndex() { return RULE_callstmt; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_aggregate_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCallstmt(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_aggregate_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCallstmt(this); } } - public final Drop_aggregate_stmtContext drop_aggregate_stmt() throws RecognitionException { - Drop_aggregate_stmtContext _localctx = new Drop_aggregate_stmtContext(_ctx, getState()); - enterRule(_localctx, 216, RULE_drop_aggregate_stmt); - int _la; + public final CallstmtContext callstmt() throws RecognitionException { + CallstmtContext _localctx = new CallstmtContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_callstmt); try { enterOuterAlt(_localctx, 1); { - setState(3145); - match(DROP); - setState(3146); - match(AGGREGATE); - setState(3149); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3147); - match(IF); - setState(3148); - match(EXISTS); - } - } - - setState(3151); - ((Drop_aggregate_stmtContext)_localctx).name = identifier(0); - setState(3152); - match(OPEN_PAREN); - setState(3153); - aggregate_signature(); - setState(3154); - match(CLOSE_PAREN); + setState(1773); + match(CALL); + setState(1774); + func_application(); } } catch (RecognitionException re) { @@ -21648,1683 +2464,48 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Drop_cast_stmtContext extends ParserRuleContext { - public Data_typeContext source_type; - public IdentifierContext target_type; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Data_typeContext data_type() { - return getRuleContext(Data_typeContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_cast_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_cast_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_cast_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_cast_stmt(this); - } - } - - public final Drop_cast_stmtContext drop_cast_stmt() throws RecognitionException { - Drop_cast_stmtContext _localctx = new Drop_cast_stmtContext(_ctx, getState()); - enterRule(_localctx, 218, RULE_drop_cast_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3156); - match(DROP); - setState(3157); - match(CAST); - setState(3160); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3158); - match(IF); - setState(3159); - match(EXISTS); - } - } - - setState(3162); - match(OPEN_PAREN); - setState(3163); - ((Drop_cast_stmtContext)_localctx).source_type = data_type(); - setState(3164); - match(AS); - setState(3165); - ((Drop_cast_stmtContext)_localctx).target_type = identifier(0); - setState(3166); - match(CLOSE_PAREN); - setState(3168); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3167); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_collation_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_collation_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_collation_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_collation_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_collation_stmt(this); - } - } - - public final Drop_collation_stmtContext drop_collation_stmt() throws RecognitionException { - Drop_collation_stmtContext _localctx = new Drop_collation_stmtContext(_ctx, getState()); - enterRule(_localctx, 220, RULE_drop_collation_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3170); - match(DROP); - setState(3171); - match(COLLATION); - setState(3174); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3172); - match(IF); - setState(3173); - match(EXISTS); - } - } - - setState(3176); - ((Drop_collation_stmtContext)_localctx).names = identifier_list(); - setState(3178); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3177); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_conversion_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode CONVERSION() { return getToken(PostgreSqlParser.CONVERSION, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_conversion_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_conversion_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_conversion_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_conversion_stmt(this); - } - } - - public final Drop_conversion_stmtContext drop_conversion_stmt() throws RecognitionException { - Drop_conversion_stmtContext _localctx = new Drop_conversion_stmtContext(_ctx, getState()); - enterRule(_localctx, 222, RULE_drop_conversion_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3180); - match(DROP); - setState(3181); - match(CONVERSION); - setState(3184); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3182); - match(IF); - setState(3183); - match(EXISTS); - } - } - - setState(3186); - ((Drop_conversion_stmtContext)_localctx).name = identifier(0); - setState(3188); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3187); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_database_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Drop_database_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_database_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_database_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_database_stmt(this); - } - } - - public final Drop_database_stmtContext drop_database_stmt() throws RecognitionException { - Drop_database_stmtContext _localctx = new Drop_database_stmtContext(_ctx, getState()); - enterRule(_localctx, 224, RULE_drop_database_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3190); - match(DROP); - setState(3191); - match(DATABASE); - setState(3194); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3192); - match(IF); - setState(3193); - match(EXISTS); - } - } - - setState(3196); - ((Drop_database_stmtContext)_localctx).name = identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_domain_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode DOMAIN() { return getToken(PostgreSqlParser.DOMAIN, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_domain_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_domain_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_domain_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_domain_stmt(this); - } - } - - public final Drop_domain_stmtContext drop_domain_stmt() throws RecognitionException { - Drop_domain_stmtContext _localctx = new Drop_domain_stmtContext(_ctx, getState()); - enterRule(_localctx, 226, RULE_drop_domain_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3198); - match(DROP); - setState(3199); - match(DOMAIN); - setState(3202); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3200); - match(IF); - setState(3201); - match(EXISTS); - } - } - - setState(3204); - ((Drop_domain_stmtContext)_localctx).names = identifier_list(); - setState(3206); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3205); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_event_trigger_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } - public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_event_trigger_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_event_trigger_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_event_trigger_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_event_trigger_stmt(this); - } - } - - public final Drop_event_trigger_stmtContext drop_event_trigger_stmt() throws RecognitionException { - Drop_event_trigger_stmtContext _localctx = new Drop_event_trigger_stmtContext(_ctx, getState()); - enterRule(_localctx, 228, RULE_drop_event_trigger_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3208); - match(DROP); - setState(3209); - match(EVENT); - setState(3210); - match(TRIGGER); - setState(3213); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3211); - match(IF); - setState(3212); - match(EXISTS); - } - } - - setState(3215); - ((Drop_event_trigger_stmtContext)_localctx).name = identifier(0); - setState(3217); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3216); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_extension_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_extension_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_extension_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_extension_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_extension_stmt(this); - } - } - - public final Drop_extension_stmtContext drop_extension_stmt() throws RecognitionException { - Drop_extension_stmtContext _localctx = new Drop_extension_stmtContext(_ctx, getState()); - enterRule(_localctx, 230, RULE_drop_extension_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3219); - match(DROP); - setState(3220); - match(EXTENSION); - setState(3223); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3221); - match(IF); - setState(3222); - match(EXISTS); - } - } - - setState(3225); - ((Drop_extension_stmtContext)_localctx).names = identifier_list(); - setState(3227); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3226); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_foreign_data_wrapper_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } - public TerminalNode DATA() { return getToken(PostgreSqlParser.DATA, 0); } - public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_foreign_data_wrapper_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_foreign_data_wrapper_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_foreign_data_wrapper_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_foreign_data_wrapper_stmt(this); - } - } - - public final Drop_foreign_data_wrapper_stmtContext drop_foreign_data_wrapper_stmt() throws RecognitionException { - Drop_foreign_data_wrapper_stmtContext _localctx = new Drop_foreign_data_wrapper_stmtContext(_ctx, getState()); - enterRule(_localctx, 232, RULE_drop_foreign_data_wrapper_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3229); - match(DROP); - setState(3230); - match(FOREIGN); - setState(3231); - match(DATA); - setState(3232); - match(WRAPPER); - setState(3235); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3233); - match(IF); - setState(3234); - match(EXISTS); - } - } - - setState(3237); - ((Drop_foreign_data_wrapper_stmtContext)_localctx).names = identifier_list(); - setState(3239); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3238); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_foreign_table_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_foreign_table_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_foreign_table_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_foreign_table_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_foreign_table_stmt(this); - } - } - - public final Drop_foreign_table_stmtContext drop_foreign_table_stmt() throws RecognitionException { - Drop_foreign_table_stmtContext _localctx = new Drop_foreign_table_stmtContext(_ctx, getState()); - enterRule(_localctx, 234, RULE_drop_foreign_table_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3241); - match(DROP); - setState(3242); - match(FOREIGN); - setState(3243); - match(TABLE); - setState(3246); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3244); - match(IF); - setState(3245); - match(EXISTS); - } - } - - setState(3248); - ((Drop_foreign_table_stmtContext)_localctx).names = identifier_list(); - setState(3250); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3249); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_function_stmtContext extends ParserRuleContext { - public Func_sig_listContext functions; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } - public Func_sig_listContext func_sig_list() { - return getRuleContext(Func_sig_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_function_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_function_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_function_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_function_stmt(this); - } - } - - public final Drop_function_stmtContext drop_function_stmt() throws RecognitionException { - Drop_function_stmtContext _localctx = new Drop_function_stmtContext(_ctx, getState()); - enterRule(_localctx, 236, RULE_drop_function_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3252); - match(DROP); - setState(3253); - match(FUNCTION); - setState(3256); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3254); - match(IF); - setState(3255); - match(EXISTS); - } - } - - setState(3258); - ((Drop_function_stmtContext)_localctx).functions = func_sig_list(); - setState(3260); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3259); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_group_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode GROUP() { return getToken(PostgreSqlParser.GROUP, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Drop_group_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_group_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_group_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_group_stmt(this); - } - } - - public final Drop_group_stmtContext drop_group_stmt() throws RecognitionException { - Drop_group_stmtContext _localctx = new Drop_group_stmtContext(_ctx, getState()); - enterRule(_localctx, 238, RULE_drop_group_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3262); - match(DROP); - setState(3263); - match(GROUP); - setState(3266); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3264); - match(IF); - setState(3265); - match(EXISTS); - } - } - - setState(3268); - ((Drop_group_stmtContext)_localctx).names = identifier_list(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_index_stmtContext extends ParserRuleContext { - public Name_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public TerminalNode CONCURRENTLY() { return getToken(PostgreSqlParser.CONCURRENTLY, 0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_index_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_index_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_index_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_index_stmt(this); - } - } - - public final Drop_index_stmtContext drop_index_stmt() throws RecognitionException { - Drop_index_stmtContext _localctx = new Drop_index_stmtContext(_ctx, getState()); - enterRule(_localctx, 240, RULE_drop_index_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3270); - match(DROP); - setState(3271); - match(INDEX); - setState(3273); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CONCURRENTLY) { - { - setState(3272); - match(CONCURRENTLY); - } - } - - setState(3277); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3275); - match(IF); - setState(3276); - match(EXISTS); - } - } - - setState(3279); - ((Drop_index_stmtContext)_localctx).names = name_list(); - setState(3281); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3280); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_language_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode PROCEDURAL() { return getToken(PostgreSqlParser.PROCEDURAL, 0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_language_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_language_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_language_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_language_stmt(this); - } - } - - public final Drop_language_stmtContext drop_language_stmt() throws RecognitionException { - Drop_language_stmtContext _localctx = new Drop_language_stmtContext(_ctx, getState()); - enterRule(_localctx, 242, RULE_drop_language_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3283); - match(DROP); - setState(3285); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PROCEDURAL) { - { - setState(3284); - match(PROCEDURAL); - } - } - - setState(3287); - match(LANGUAGE); - setState(3290); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3288); - match(IF); - setState(3289); - match(EXISTS); - } - } - - setState(3292); - ((Drop_language_stmtContext)_localctx).name = identifier(0); - setState(3294); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3293); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_materialized_view_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } - public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_materialized_view_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_materialized_view_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_materialized_view_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_materialized_view_stmt(this); - } - } - - public final Drop_materialized_view_stmtContext drop_materialized_view_stmt() throws RecognitionException { - Drop_materialized_view_stmtContext _localctx = new Drop_materialized_view_stmtContext(_ctx, getState()); - enterRule(_localctx, 244, RULE_drop_materialized_view_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3296); - match(DROP); - setState(3297); - match(MATERIALIZED); - setState(3298); - match(VIEW); - setState(3301); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3299); - match(IF); - setState(3300); - match(EXISTS); - } - } - - setState(3303); - ((Drop_materialized_view_stmtContext)_localctx).names = identifier_list(); - setState(3305); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3304); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_operator_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Drop_operator_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_operator_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_operator_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_operator_stmt(this); - } - } - - public final Drop_operator_stmtContext drop_operator_stmt() throws RecognitionException { - Drop_operator_stmtContext _localctx = new Drop_operator_stmtContext(_ctx, getState()); - enterRule(_localctx, 246, RULE_drop_operator_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3307); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_operator_class_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } - public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public Index_methodContext index_method() { - return getRuleContext(Index_methodContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_operator_class_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_operator_class_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_operator_class_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_operator_class_stmt(this); - } - } - - public final Drop_operator_class_stmtContext drop_operator_class_stmt() throws RecognitionException { - Drop_operator_class_stmtContext _localctx = new Drop_operator_class_stmtContext(_ctx, getState()); - enterRule(_localctx, 248, RULE_drop_operator_class_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3309); - match(DROP); - setState(3310); - match(OPERATOR); - setState(3311); - match(CLASS); - setState(3314); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3312); - match(IF); - setState(3313); - match(EXISTS); - } - } - - setState(3316); - ((Drop_operator_class_stmtContext)_localctx).name = identifier(0); - setState(3317); - match(USING); - setState(3318); - index_method(); - setState(3320); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3319); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_operator_family_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } - public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public Index_methodContext index_method() { - return getRuleContext(Index_methodContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_operator_family_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_operator_family_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_operator_family_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_operator_family_stmt(this); - } - } - - public final Drop_operator_family_stmtContext drop_operator_family_stmt() throws RecognitionException { - Drop_operator_family_stmtContext _localctx = new Drop_operator_family_stmtContext(_ctx, getState()); - enterRule(_localctx, 250, RULE_drop_operator_family_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3322); - match(DROP); - setState(3323); - match(OPERATOR); - setState(3324); - match(FAMILY); - setState(3327); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3325); - match(IF); - setState(3326); - match(EXISTS); - } - } - - setState(3329); - ((Drop_operator_family_stmtContext)_localctx).name = identifier(0); - setState(3330); - match(USING); - setState(3331); - index_method(); - setState(3333); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3332); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_owned_stmtContext extends ParserRuleContext { - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public Role_name_listContext role_name_list() { - return getRuleContext(Role_name_listContext.class,0); - } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_owned_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_owned_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_owned_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_owned_stmt(this); - } - } - - public final Drop_owned_stmtContext drop_owned_stmt() throws RecognitionException { - Drop_owned_stmtContext _localctx = new Drop_owned_stmtContext(_ctx, getState()); - enterRule(_localctx, 252, RULE_drop_owned_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3335); - match(DROP); - setState(3336); - match(OWNED); - setState(3337); - match(BY); - setState(3338); - role_name_list(); - setState(3340); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3339); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_policy_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext table_name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode POLICY() { return getToken(PostgreSqlParser.POLICY, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_policy_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_policy_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_policy_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_policy_stmt(this); - } - } - - public final Drop_policy_stmtContext drop_policy_stmt() throws RecognitionException { - Drop_policy_stmtContext _localctx = new Drop_policy_stmtContext(_ctx, getState()); - enterRule(_localctx, 254, RULE_drop_policy_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3342); - match(DROP); - setState(3343); - match(POLICY); - setState(3346); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3344); - match(IF); - setState(3345); - match(EXISTS); - } - } - - setState(3348); - ((Drop_policy_stmtContext)_localctx).name = identifier(0); - setState(3349); - match(ON); - setState(3350); - ((Drop_policy_stmtContext)_localctx).table_name = identifier(0); - setState(3352); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3351); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_publication_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_publication_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_publication_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_publication_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_publication_stmt(this); - } - } - - public final Drop_publication_stmtContext drop_publication_stmt() throws RecognitionException { - Drop_publication_stmtContext _localctx = new Drop_publication_stmtContext(_ctx, getState()); - enterRule(_localctx, 256, RULE_drop_publication_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3354); - match(DROP); - setState(3355); - match(PUBLICATION); - setState(3358); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3356); - match(IF); - setState(3357); - match(EXISTS); - } - } - - setState(3360); - ((Drop_publication_stmtContext)_localctx).names = identifier_list(); - setState(3362); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3361); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_role_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public static class CreaterolestmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); + public RoleidContext roleid() { + return getRuleContext(RoleidContext.class,0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Drop_role_stmtContext(ParserRuleContext parent, int invokingState) { + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public OptrolelistContext optrolelist() { + return getRuleContext(OptrolelistContext.class,0); + } + public CreaterolestmtContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_drop_role_stmt; } + @Override public int getRuleIndex() { return RULE_createrolestmt; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_role_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreaterolestmt(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_role_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreaterolestmt(this); } } - public final Drop_role_stmtContext drop_role_stmt() throws RecognitionException { - Drop_role_stmtContext _localctx = new Drop_role_stmtContext(_ctx, getState()); - enterRule(_localctx, 258, RULE_drop_role_stmt); - int _la; + public final CreaterolestmtContext createrolestmt() throws RecognitionException { + CreaterolestmtContext _localctx = new CreaterolestmtContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_createrolestmt); try { enterOuterAlt(_localctx, 1); { - setState(3364); - match(DROP); - setState(3365); + setState(1776); + match(CREATE); + setState(1777); match(ROLE); - setState(3368); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3366); - match(IF); - setState(3367); - match(EXISTS); - } - } - - setState(3370); - ((Drop_role_stmtContext)_localctx).names = identifier_list(); + setState(1778); + roleid(); + setState(1779); + opt_with(); + setState(1780); + optrolelist(); } } catch (RecognitionException re) { @@ -23339,8660 +2520,39 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Drop_rule_stmtContext extends ParserRuleContext { - public Name_Context name; - public IdentifierContext table_name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_rule_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_rule_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_rule_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_rule_stmt(this); - } - } - - public final Drop_rule_stmtContext drop_rule_stmt() throws RecognitionException { - Drop_rule_stmtContext _localctx = new Drop_rule_stmtContext(_ctx, getState()); - enterRule(_localctx, 260, RULE_drop_rule_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3372); - match(DROP); - setState(3373); - match(RULE); - setState(3376); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3374); - match(IF); - setState(3375); - match(EXISTS); - } - } - - setState(3378); - ((Drop_rule_stmtContext)_localctx).name = name_(); - setState(3379); - match(ON); - setState(3380); - ((Drop_rule_stmtContext)_localctx).table_name = identifier(0); - setState(3382); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3381); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_schema_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_schema_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_schema_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_schema_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_schema_stmt(this); - } - } - - public final Drop_schema_stmtContext drop_schema_stmt() throws RecognitionException { - Drop_schema_stmtContext _localctx = new Drop_schema_stmtContext(_ctx, getState()); - enterRule(_localctx, 262, RULE_drop_schema_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3384); - match(DROP); - setState(3385); - match(SCHEMA); - setState(3388); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3386); - match(IF); - setState(3387); - match(EXISTS); - } - } - - setState(3390); - ((Drop_schema_stmtContext)_localctx).names = identifier_list(); - setState(3392); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3391); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_sequence_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_sequence_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_sequence_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_sequence_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_sequence_stmt(this); - } - } - - public final Drop_sequence_stmtContext drop_sequence_stmt() throws RecognitionException { - Drop_sequence_stmtContext _localctx = new Drop_sequence_stmtContext(_ctx, getState()); - enterRule(_localctx, 264, RULE_drop_sequence_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3394); - match(DROP); - setState(3395); - match(SEQUENCE); - setState(3398); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3396); - match(IF); - setState(3397); - match(EXISTS); - } - } - - setState(3400); - ((Drop_sequence_stmtContext)_localctx).names = identifier_list(); - setState(3402); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3401); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_server_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_server_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_server_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_server_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_server_stmt(this); - } - } - - public final Drop_server_stmtContext drop_server_stmt() throws RecognitionException { - Drop_server_stmtContext _localctx = new Drop_server_stmtContext(_ctx, getState()); - enterRule(_localctx, 266, RULE_drop_server_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3404); - match(DROP); - setState(3405); - match(SERVER); - setState(3408); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3406); - match(IF); - setState(3407); - match(EXISTS); - } - } - - setState(3410); - ((Drop_server_stmtContext)_localctx).names = identifier_list(); - setState(3412); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3411); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_statistics_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Drop_statistics_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_statistics_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_statistics_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_statistics_stmt(this); - } - } - - public final Drop_statistics_stmtContext drop_statistics_stmt() throws RecognitionException { - Drop_statistics_stmtContext _localctx = new Drop_statistics_stmtContext(_ctx, getState()); - enterRule(_localctx, 268, RULE_drop_statistics_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3414); - match(DROP); - setState(3415); - match(STATISTICS); - setState(3418); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3416); - match(IF); - setState(3417); - match(EXISTS); - } - } - - setState(3420); - ((Drop_statistics_stmtContext)_localctx).names = identifier_list(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_subscription_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_subscription_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_subscription_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_subscription_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_subscription_stmt(this); - } - } - - public final Drop_subscription_stmtContext drop_subscription_stmt() throws RecognitionException { - Drop_subscription_stmtContext _localctx = new Drop_subscription_stmtContext(_ctx, getState()); - enterRule(_localctx, 270, RULE_drop_subscription_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3422); - match(DROP); - setState(3423); - match(SUBSCRIPTION); - setState(3426); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3424); - match(IF); - setState(3425); - match(EXISTS); - } - } - - setState(3428); - ((Drop_subscription_stmtContext)_localctx).name = identifier(0); - setState(3430); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3429); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_table_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_table_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_table_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_table_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_table_stmt(this); - } - } - - public final Drop_table_stmtContext drop_table_stmt() throws RecognitionException { - Drop_table_stmtContext _localctx = new Drop_table_stmtContext(_ctx, getState()); - enterRule(_localctx, 272, RULE_drop_table_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3432); - match(DROP); - setState(3433); - match(TABLE); - setState(3436); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3434); - match(IF); - setState(3435); - match(EXISTS); - } - } - - setState(3438); - ((Drop_table_stmtContext)_localctx).names = identifier_list(); - setState(3440); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3439); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_tablespace_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Drop_tablespace_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_tablespace_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_tablespace_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_tablespace_stmt(this); - } - } - - public final Drop_tablespace_stmtContext drop_tablespace_stmt() throws RecognitionException { - Drop_tablespace_stmtContext _localctx = new Drop_tablespace_stmtContext(_ctx, getState()); - enterRule(_localctx, 274, RULE_drop_tablespace_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3442); - match(DROP); - setState(3443); - match(TABLESPACE); - setState(3446); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3444); - match(IF); - setState(3445); - match(EXISTS); - } - } - - setState(3448); - ((Drop_tablespace_stmtContext)_localctx).name = identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_text_search_config_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } - public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_text_search_config_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_text_search_config_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_text_search_config_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_text_search_config_stmt(this); - } - } - - public final Drop_text_search_config_stmtContext drop_text_search_config_stmt() throws RecognitionException { - Drop_text_search_config_stmtContext _localctx = new Drop_text_search_config_stmtContext(_ctx, getState()); - enterRule(_localctx, 276, RULE_drop_text_search_config_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3450); - match(DROP); - setState(3451); - match(TEXT); - setState(3452); - match(SEARCH); - setState(3453); - match(CONFIGURATION); - setState(3456); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3454); - match(IF); - setState(3455); - match(EXISTS); - } - } - - setState(3458); - ((Drop_text_search_config_stmtContext)_localctx).name = identifier(0); - setState(3460); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3459); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_text_search_dict_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } - public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_text_search_dict_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_text_search_dict_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_text_search_dict_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_text_search_dict_stmt(this); - } - } - - public final Drop_text_search_dict_stmtContext drop_text_search_dict_stmt() throws RecognitionException { - Drop_text_search_dict_stmtContext _localctx = new Drop_text_search_dict_stmtContext(_ctx, getState()); - enterRule(_localctx, 278, RULE_drop_text_search_dict_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3462); - match(DROP); - setState(3463); - match(TEXT); - setState(3464); - match(SEARCH); - setState(3465); - match(DICTIONARY); - setState(3468); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3466); - match(IF); - setState(3467); - match(EXISTS); - } - } - - setState(3470); - ((Drop_text_search_dict_stmtContext)_localctx).name = identifier(0); - setState(3472); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3471); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_text_search_parser_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } - public TerminalNode PARSER() { return getToken(PostgreSqlParser.PARSER, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_text_search_parser_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_text_search_parser_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_text_search_parser_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_text_search_parser_stmt(this); - } - } - - public final Drop_text_search_parser_stmtContext drop_text_search_parser_stmt() throws RecognitionException { - Drop_text_search_parser_stmtContext _localctx = new Drop_text_search_parser_stmtContext(_ctx, getState()); - enterRule(_localctx, 280, RULE_drop_text_search_parser_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3474); - match(DROP); - setState(3475); - match(TEXT); - setState(3476); - match(SEARCH); - setState(3477); - match(PARSER); - setState(3480); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3478); - match(IF); - setState(3479); - match(EXISTS); - } - } - - setState(3482); - ((Drop_text_search_parser_stmtContext)_localctx).name = identifier(0); - setState(3484); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3483); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_text_search_template_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } - public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_text_search_template_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_text_search_template_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_text_search_template_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_text_search_template_stmt(this); - } - } - - public final Drop_text_search_template_stmtContext drop_text_search_template_stmt() throws RecognitionException { - Drop_text_search_template_stmtContext _localctx = new Drop_text_search_template_stmtContext(_ctx, getState()); - enterRule(_localctx, 282, RULE_drop_text_search_template_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3486); - match(DROP); - setState(3487); - match(TEXT); - setState(3488); - match(SEARCH); - setState(3489); - match(TEMPLATE); - setState(3492); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3490); - match(IF); - setState(3491); - match(EXISTS); - } - } - - setState(3494); - ((Drop_text_search_template_stmtContext)_localctx).name = identifier(0); - setState(3496); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3495); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_transform_stmtContext extends ParserRuleContext { - public IdentifierContext type_name_; - public IdentifierContext lang_name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TRANSFORM() { return getToken(PostgreSqlParser.TRANSFORM, 0); } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Drop_transform_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_transform_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_transform_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_transform_stmt(this); - } - } - - public final Drop_transform_stmtContext drop_transform_stmt() throws RecognitionException { - Drop_transform_stmtContext _localctx = new Drop_transform_stmtContext(_ctx, getState()); - enterRule(_localctx, 284, RULE_drop_transform_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3498); - match(DROP); - setState(3499); - match(TRANSFORM); - setState(3502); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3500); - match(IF); - setState(3501); - match(EXISTS); - } - } - - setState(3504); - match(FOR); - setState(3505); - ((Drop_transform_stmtContext)_localctx).type_name_ = identifier(0); - setState(3506); - match(LANGUAGE); - setState(3507); - ((Drop_transform_stmtContext)_localctx).lang_name = identifier(0); - setState(3508); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_trigger_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext table_name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_trigger_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_trigger_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_trigger_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_trigger_stmt(this); - } - } - - public final Drop_trigger_stmtContext drop_trigger_stmt() throws RecognitionException { - Drop_trigger_stmtContext _localctx = new Drop_trigger_stmtContext(_ctx, getState()); - enterRule(_localctx, 286, RULE_drop_trigger_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3510); - match(DROP); - setState(3511); - match(TRIGGER); - setState(3514); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3512); - match(IF); - setState(3513); - match(EXISTS); - } - } - - setState(3516); - ((Drop_trigger_stmtContext)_localctx).name = identifier(0); - setState(3517); - match(ON); - setState(3518); - ((Drop_trigger_stmtContext)_localctx).table_name = identifier(0); - setState(3520); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3519); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_type_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode TYPE() { return getToken(PostgreSqlParser.TYPE, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_type_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_type_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_type_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_type_stmt(this); - } - } - - public final Drop_type_stmtContext drop_type_stmt() throws RecognitionException { - Drop_type_stmtContext _localctx = new Drop_type_stmtContext(_ctx, getState()); - enterRule(_localctx, 288, RULE_drop_type_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3522); - match(DROP); - setState(3523); - match(TYPE); - setState(3526); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3524); - match(IF); - setState(3525); - match(EXISTS); - } - } - - setState(3528); - ((Drop_type_stmtContext)_localctx).names = identifier_list(); - setState(3530); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3529); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_user_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Drop_user_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_user_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_user_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_user_stmt(this); - } - } - - public final Drop_user_stmtContext drop_user_stmt() throws RecognitionException { - Drop_user_stmtContext _localctx = new Drop_user_stmtContext(_ctx, getState()); - enterRule(_localctx, 290, RULE_drop_user_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3532); - match(DROP); - setState(3533); - match(USER); - setState(3536); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3534); - match(IF); - setState(3535); - match(EXISTS); - } - } - - setState(3538); - ((Drop_user_stmtContext)_localctx).names = identifier_list(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_user_mapping_stmtContext extends ParserRuleContext { - public Name_Context user_name; - public IdentifierContext server_name; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public List USER() { return getTokens(PostgreSqlParser.USER); } - public TerminalNode USER(int i) { - return getToken(PostgreSqlParser.USER, i); - } - public TerminalNode MAPPING() { return getToken(PostgreSqlParser.MAPPING, 0); } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public TerminalNode PUBLIC() { return getToken(PostgreSqlParser.PUBLIC, 0); } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public Drop_user_mapping_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_user_mapping_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_user_mapping_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_user_mapping_stmt(this); - } - } - - public final Drop_user_mapping_stmtContext drop_user_mapping_stmt() throws RecognitionException { - Drop_user_mapping_stmtContext _localctx = new Drop_user_mapping_stmtContext(_ctx, getState()); - enterRule(_localctx, 292, RULE_drop_user_mapping_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3540); - match(DROP); - setState(3541); - match(USER); - setState(3542); - match(MAPPING); - setState(3545); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3543); - match(IF); - setState(3544); - match(EXISTS); - } - } - - setState(3547); - match(FOR); - setState(3553); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,358,_ctx) ) { - case 1: - { - setState(3548); - ((Drop_user_mapping_stmtContext)_localctx).user_name = name_(); - } - break; - case 2: - { - setState(3549); - match(USER); - } - break; - case 3: - { - setState(3550); - match(CURRENT_USER); - } - break; - case 4: - { - setState(3551); - match(SESSION_USER); - } - break; - case 5: - { - setState(3552); - match(PUBLIC); - } - break; - } - setState(3555); - match(SERVER); - setState(3556); - ((Drop_user_mapping_stmtContext)_localctx).server_name = identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Drop_view_stmtContext extends ParserRuleContext { - public Identifier_listContext names; - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } - public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IF() { return getToken(PostgreSqlParser.IF, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Drop_view_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_drop_view_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_view_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_view_stmt(this); - } - } - - public final Drop_view_stmtContext drop_view_stmt() throws RecognitionException { - Drop_view_stmtContext _localctx = new Drop_view_stmtContext(_ctx, getState()); - enterRule(_localctx, 294, RULE_drop_view_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3558); - match(DROP); - setState(3559); - match(VIEW); - setState(3562); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IF) { - { - setState(3560); - match(IF); - setState(3561); - match(EXISTS); - } - } - - setState(3564); - ((Drop_view_stmtContext)_localctx).names = identifier_list(); - setState(3566); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(3565); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Execute_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Expr_listContext expr_list() { - return getRuleContext(Expr_listContext.class,0); - } - public Execute_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_execute_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExecute_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExecute_stmt(this); - } - } - - public final Execute_stmtContext execute_stmt() throws RecognitionException { - Execute_stmtContext _localctx = new Execute_stmtContext(_ctx, getState()); - enterRule(_localctx, 296, RULE_execute_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3568); - match(EXECUTE); - setState(3569); - ((Execute_stmtContext)_localctx).name = identifier(0); - setState(3571); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(3570); - expr_list(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Explain_stmtContext extends ParserRuleContext { - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public Insert_stmtContext insert_stmt() { - return getRuleContext(Insert_stmtContext.class,0); - } - public Update_stmtContext update_stmt() { - return getRuleContext(Update_stmtContext.class,0); - } - public Delete_stmtContext delete_stmt() { - return getRuleContext(Delete_stmtContext.class,0); - } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); - } - public Execute_stmtContext execute_stmt() { - return getRuleContext(Execute_stmtContext.class,0); - } - public Declare_stmtContext declare_stmt() { - return getRuleContext(Declare_stmtContext.class,0); - } - public Create_table_as_stmtContext create_table_as_stmt() { - return getRuleContext(Create_table_as_stmtContext.class,0); - } - public Create_materialized_view_stmtContext create_materialized_view_stmt() { - return getRuleContext(Create_materialized_view_stmtContext.class,0); - } - public TerminalNode EXPLAIN() { return getToken(PostgreSqlParser.EXPLAIN, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List explain_parameter() { - return getRuleContexts(Explain_parameterContext.class); - } - public Explain_parameterContext explain_parameter(int i) { - return getRuleContext(Explain_parameterContext.class,i); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode ANALYZE() { return getToken(PostgreSqlParser.ANALYZE, 0); } - public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Explain_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explain_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplain_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplain_stmt(this); - } - } - - public final Explain_stmtContext explain_stmt() throws RecognitionException { - Explain_stmtContext _localctx = new Explain_stmtContext(_ctx, getState()); - enterRule(_localctx, 298, RULE_explain_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3592); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,365,_ctx) ) { - case 1: - { - { - setState(3573); - match(EXPLAIN); - setState(3575); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ANALYZE) { - { - setState(3574); - match(ANALYZE); - } - } - - setState(3578); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==VERBOSE) { - { - setState(3577); - match(VERBOSE); - } - } - - } - } - break; - case 2: - { - { - setState(3580); - match(EXPLAIN); - setState(3581); - match(OPEN_PAREN); - setState(3582); - explain_parameter(); - setState(3587); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(3583); - match(COMMA); - setState(3584); - explain_parameter(); - } - } - setState(3589); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3590); - match(CLOSE_PAREN); - } - } - break; - } - setState(3603); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,366,_ctx) ) { - case 1: - { - setState(3594); - select_stmt(); - } - break; - case 2: - { - setState(3595); - insert_stmt(); - } - break; - case 3: - { - setState(3596); - update_stmt(); - } - break; - case 4: - { - setState(3597); - delete_stmt(); - } - break; - case 5: - { - setState(3598); - values_stmt(); - } - break; - case 6: - { - setState(3599); - execute_stmt(); - } - break; - case 7: - { - setState(3600); - declare_stmt(); - } - break; - case 8: - { - setState(3601); - create_table_as_stmt(); - } - break; - case 9: - { - setState(3602); - create_materialized_view_stmt(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Fetch_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Fetch_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fetch_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFetch_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFetch_stmt(this); - } - } - - public final Fetch_stmtContext fetch_stmt() throws RecognitionException { - Fetch_stmtContext _localctx = new Fetch_stmtContext(_ctx, getState()); - enterRule(_localctx, 300, RULE_fetch_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3605); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Grant_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Grant_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_grant_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrant_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrant_stmt(this); - } - } - - public final Grant_stmtContext grant_stmt() throws RecognitionException { - Grant_stmtContext _localctx = new Grant_stmtContext(_ctx, getState()); - enterRule(_localctx, 302, RULE_grant_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3607); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Import_foreign_schema_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Import_foreign_schema_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_import_foreign_schema_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterImport_foreign_schema_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitImport_foreign_schema_stmt(this); - } - } - - public final Import_foreign_schema_stmtContext import_foreign_schema_stmt() throws RecognitionException { - Import_foreign_schema_stmtContext _localctx = new Import_foreign_schema_stmtContext(_ctx, getState()); - enterRule(_localctx, 304, RULE_import_foreign_schema_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3609); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Insert_stmtContext extends ParserRuleContext { - public IdentifierContext alias_; - public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } - public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } - public TerminalNode VALUES() { return getToken(PostgreSqlParser.VALUES, 0); } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); - } - public With_clauseContext with_clause() { - return getRuleContext(With_clauseContext.class,0); - } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public TerminalNode OVERRIDING() { return getToken(PostgreSqlParser.OVERRIDING, 0); } - public TerminalNode VALUE() { return getToken(PostgreSqlParser.VALUE, 0); } - public List ON() { return getTokens(PostgreSqlParser.ON); } - public TerminalNode ON(int i) { - return getToken(PostgreSqlParser.ON, i); - } - public TerminalNode CONFLICT() { return getToken(PostgreSqlParser.CONFLICT, 0); } - public Returning_clauseContext returning_clause() { - return getRuleContext(Returning_clauseContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public List column_name() { - return getRuleContexts(Column_nameContext.class); - } - public Column_nameContext column_name(int i) { - return getRuleContext(Column_nameContext.class,i); - } - public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } - public List where_clause() { - return getRuleContexts(Where_clauseContext.class); - } - public Where_clauseContext where_clause(int i) { - return getRuleContext(Where_clauseContext.class,i); - } - public TerminalNode SYSTEM() { return getToken(PostgreSqlParser.SYSTEM, 0); } - public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } - public TerminalNode DO() { return getToken(PostgreSqlParser.DO, 0); } - public TerminalNode NOTHING() { return getToken(PostgreSqlParser.NOTHING, 0); } - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public Updater_clauseContext updater_clause() { - return getRuleContext(Updater_clauseContext.class,0); - } - public Insert_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_insert_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInsert_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInsert_stmt(this); - } - } - - public final Insert_stmtContext insert_stmt() throws RecognitionException { - Insert_stmtContext _localctx = new Insert_stmtContext(_ctx, getState()); - enterRule(_localctx, 306, RULE_insert_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3612); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(3611); - with_clause(); - } - } - - setState(3614); - match(INSERT); - setState(3615); - match(INTO); - setState(3616); - table_name_(); - setState(3619); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(3617); - match(AS); - setState(3618); - ((Insert_stmtContext)_localctx).alias_ = identifier(0); - } - } - - setState(3625); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,369,_ctx) ) { - case 1: - { - setState(3621); - match(OPEN_PAREN); - setState(3622); - name_list(); - setState(3623); - match(CLOSE_PAREN); - } - break; - } - setState(3632); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OVERRIDING) { - { - setState(3627); - match(OVERRIDING); - setState(3629); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SYSTEM || _la==USER) { - { - setState(3628); - _la = _input.LA(1); - if ( !(_la==SYSTEM || _la==USER) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(3631); - match(VALUE); - } - } - - setState(3638); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,372,_ctx) ) { - case 1: - { - setState(3634); - match(DEFAULT); - setState(3635); - match(VALUES); - } - break; - case 2: - { - setState(3636); - select_stmt(); - } - break; - case 3: - { - setState(3637); - values_stmt(); - } - break; - } - setState(3667); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ON) { - { - setState(3640); - match(ON); - setState(3641); - match(CONFLICT); - setState(3646); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(3642); - match(OPEN_PAREN); - setState(3643); - column_name(); - setState(3644); - match(CLOSE_PAREN); - } - } - - setState(3651); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ON) { - { - setState(3648); - match(ON); - setState(3649); - match(CONSTRAINT); - setState(3650); - column_name(); - } - } - - setState(3654); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(3653); - where_clause(); - } - } - - setState(3665); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,377,_ctx) ) { - case 1: - { - { - setState(3656); - match(DO); - setState(3657); - match(NOTHING); - } - } - break; - case 2: - { - { - setState(3658); - match(DO); - setState(3659); - match(UPDATE); - setState(3660); - match(SET); - setState(3661); - updater_clause(); - setState(3663); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(3662); - where_clause(); - } - } - - } - } - break; - } - } - } - - setState(3670); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==RETURNING) { - { - setState(3669); - returning_clause(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Listen_stmtContext extends ParserRuleContext { - public IdentifierContext channel; - public TerminalNode LISTEN() { return getToken(PostgreSqlParser.LISTEN, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Listen_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_listen_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterListen_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitListen_stmt(this); - } - } - - public final Listen_stmtContext listen_stmt() throws RecognitionException { - Listen_stmtContext _localctx = new Listen_stmtContext(_ctx, getState()); - enterRule(_localctx, 308, RULE_listen_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3672); - match(LISTEN); - setState(3673); - ((Listen_stmtContext)_localctx).channel = identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Load_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Load_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_load_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLoad_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLoad_stmt(this); - } - } - - public final Load_stmtContext load_stmt() throws RecognitionException { - Load_stmtContext _localctx = new Load_stmtContext(_ctx, getState()); - enterRule(_localctx, 310, RULE_load_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3675); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Lock_stmtContext extends ParserRuleContext { - public Name_Context name; - public TerminalNode LOCK() { return getToken(PostgreSqlParser.LOCK, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public TerminalNode IN() { return getToken(PostgreSqlParser.IN, 0); } - public TerminalNode MODE() { return getToken(PostgreSqlParser.MODE, 0); } - public TerminalNode NOWAIT() { return getToken(PostgreSqlParser.NOWAIT, 0); } - public TerminalNode ACCESS() { return getToken(PostgreSqlParser.ACCESS, 0); } - public TerminalNode SHARE() { return getToken(PostgreSqlParser.SHARE, 0); } - public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } - public TerminalNode EXCLUSIVE() { return getToken(PostgreSqlParser.EXCLUSIVE, 0); } - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public Lock_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lock_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLock_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLock_stmt(this); - } - } - - public final Lock_stmtContext lock_stmt() throws RecognitionException { - Lock_stmtContext _localctx = new Lock_stmtContext(_ctx, getState()); - enterRule(_localctx, 312, RULE_lock_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3677); - match(LOCK); - setState(3679); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TABLE) { - { - setState(3678); - match(TABLE); - } - } - - setState(3682); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(3681); - match(ONLY); - } - } - - setState(3684); - ((Lock_stmtContext)_localctx).name = name_(); - setState(3686); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==STAR) { - { - setState(3685); - match(STAR); - } - } - - setState(3708); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN) { - { - setState(3688); - match(IN); - setState(3705); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,383,_ctx) ) { - case 1: - { - setState(3689); - match(ACCESS); - setState(3690); - match(SHARE); - } - break; - case 2: - { - setState(3691); - match(ROW); - setState(3692); - match(SHARE); - } - break; - case 3: - { - setState(3693); - match(ROW); - setState(3694); - match(EXCLUSIVE); - } - break; - case 4: - { - setState(3695); - match(SHARE); - setState(3696); - match(UPDATE); - setState(3697); - match(EXCLUSIVE); - } - break; - case 5: - { - setState(3698); - match(SHARE); - } - break; - case 6: - { - setState(3699); - match(SHARE); - setState(3700); - match(ROW); - setState(3701); - match(EXCLUSIVE); - } - break; - case 7: - { - setState(3702); - match(EXCLUSIVE); - } - break; - case 8: - { - setState(3703); - match(ACCESS); - setState(3704); - match(EXCLUSIVE); - } - break; - } - setState(3707); - match(MODE); - } - } - - setState(3711); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOWAIT) { - { - setState(3710); - match(NOWAIT); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Move_stmtContext extends ParserRuleContext { - public Name_Context cursor_name; - public TerminalNode MOVE() { return getToken(PostgreSqlParser.MOVE, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } - public TerminalNode PRIOR() { return getToken(PostgreSqlParser.PRIOR, 0); } - public TerminalNode FIRST() { return getToken(PostgreSqlParser.FIRST, 0); } - public TerminalNode LAST() { return getToken(PostgreSqlParser.LAST, 0); } - public TerminalNode ABSOLUTE() { return getToken(PostgreSqlParser.ABSOLUTE, 0); } - public TerminalNode INTEGER() { return getToken(PostgreSqlParser.INTEGER, 0); } - public TerminalNode RELATIVE() { return getToken(PostgreSqlParser.RELATIVE, 0); } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral() { - return getRuleContext(ParameterOrIntegerLiteralContext.class,0); - } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public TerminalNode FORWARD() { return getToken(PostgreSqlParser.FORWARD, 0); } - public TerminalNode BACKWARD() { return getToken(PostgreSqlParser.BACKWARD, 0); } - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public TerminalNode IN() { return getToken(PostgreSqlParser.IN, 0); } - public Move_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_move_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterMove_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitMove_stmt(this); - } - } - - public final Move_stmtContext move_stmt() throws RecognitionException { - Move_stmtContext _localctx = new Move_stmtContext(_ctx, getState()); - enterRule(_localctx, 314, RULE_move_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3713); - match(MOVE); - setState(3739); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,390,_ctx) ) { - case 1: - { - setState(3734); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NEXT: - { - setState(3714); - match(NEXT); - } - break; - case PRIOR: - { - setState(3715); - match(PRIOR); - } - break; - case FIRST: - { - setState(3716); - match(FIRST); - } - break; - case LAST: - { - setState(3717); - match(LAST); - } - break; - case ABSOLUTE: - { - setState(3718); - match(ABSOLUTE); - setState(3719); - match(INTEGER); - } - break; - case RELATIVE: - { - setState(3720); - match(RELATIVE); - setState(3721); - parameterOrIntegerLiteral(); - } - break; - case COLON: - case INTEGER_LITERAL: - case QMARK: - { - setState(3722); - parameterOrIntegerLiteral(); - } - break; - case ALL: - { - setState(3723); - match(ALL); - } - break; - case FORWARD: - { - setState(3724); - match(FORWARD); - setState(3727); - _errHandler.sync(this); - switch (_input.LA(1)) { - case COLON: - case INTEGER_LITERAL: - case QMARK: - { - setState(3725); - parameterOrIntegerLiteral(); - } - break; - case ALL: - { - setState(3726); - match(ALL); - } - break; - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FROM: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case IN: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - break; - default: - break; - } - } - break; - case BACKWARD: - { - setState(3729); - match(BACKWARD); - setState(3732); - _errHandler.sync(this); - switch (_input.LA(1)) { - case COLON: - case INTEGER_LITERAL: - case QMARK: - { - setState(3730); - parameterOrIntegerLiteral(); - } - break; - case ALL: - { - setState(3731); - match(ALL); - } - break; - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FROM: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case IN: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - break; - default: - break; - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3737); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FROM || _la==IN) { - { - setState(3736); - _la = _input.LA(1); - if ( !(_la==FROM || _la==IN) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - break; - } - setState(3741); - ((Move_stmtContext)_localctx).cursor_name = name_(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Notify_stmtContext extends ParserRuleContext { - public Name_Context channel; - public Token payload; - public TerminalNode NOTIFY() { return getToken(PostgreSqlParser.NOTIFY, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public Notify_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_notify_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNotify_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNotify_stmt(this); - } - } - - public final Notify_stmtContext notify_stmt() throws RecognitionException { - Notify_stmtContext _localctx = new Notify_stmtContext(_ctx, getState()); - enterRule(_localctx, 316, RULE_notify_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3743); - match(NOTIFY); - setState(3744); - ((Notify_stmtContext)_localctx).channel = name_(); - setState(3747); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(3745); - match(COMMA); - setState(3746); - ((Notify_stmtContext)_localctx).payload = match(SINGLEQ_STRING_LITERAL); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Prepare_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode PREPARE() { return getToken(PostgreSqlParser.PREPARE, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public Insert_stmtContext insert_stmt() { - return getRuleContext(Insert_stmtContext.class,0); - } - public Update_stmtContext update_stmt() { - return getRuleContext(Update_stmtContext.class,0); - } - public Delete_stmtContext delete_stmt() { - return getRuleContext(Delete_stmtContext.class,0); - } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Data_type_listContext data_type_list() { - return getRuleContext(Data_type_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Prepare_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_prepare_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPrepare_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPrepare_stmt(this); - } - } - - public final Prepare_stmtContext prepare_stmt() throws RecognitionException { - Prepare_stmtContext _localctx = new Prepare_stmtContext(_ctx, getState()); - enterRule(_localctx, 318, RULE_prepare_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3749); - match(PREPARE); - setState(3750); - ((Prepare_stmtContext)_localctx).name = identifier(0); - setState(3755); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(3751); - match(OPEN_PAREN); - setState(3752); - data_type_list(); - setState(3753); - match(CLOSE_PAREN); - } - } - - setState(3757); - match(AS); - setState(3763); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,393,_ctx) ) { - case 1: - { - setState(3758); - select_stmt(); - } - break; - case 2: - { - setState(3759); - insert_stmt(); - } - break; - case 3: - { - setState(3760); - update_stmt(); - } - break; - case 4: - { - setState(3761); - delete_stmt(); - } - break; - case 5: - { - setState(3762); - values_stmt(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Prepare_transaction_stmtContext extends ParserRuleContext { - public Name_Context name; - public TerminalNode PREPARE() { return getToken(PostgreSqlParser.PREPARE, 0); } - public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public Prepare_transaction_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_prepare_transaction_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPrepare_transaction_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPrepare_transaction_stmt(this); - } - } - - public final Prepare_transaction_stmtContext prepare_transaction_stmt() throws RecognitionException { - Prepare_transaction_stmtContext _localctx = new Prepare_transaction_stmtContext(_ctx, getState()); - enterRule(_localctx, 320, RULE_prepare_transaction_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3765); - match(PREPARE); - setState(3766); - match(TRANSACTION); - setState(3767); - ((Prepare_transaction_stmtContext)_localctx).name = name_(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Reassign_owned_stmtContext extends ParserRuleContext { - public TerminalNode REASSIGN() { return getToken(PostgreSqlParser.REASSIGN, 0); } - public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List CURRENT_USER() { return getTokens(PostgreSqlParser.CURRENT_USER); } - public TerminalNode CURRENT_USER(int i) { - return getToken(PostgreSqlParser.CURRENT_USER, i); - } - public List SESSION_USER() { return getTokens(PostgreSqlParser.SESSION_USER); } - public TerminalNode SESSION_USER(int i) { - return getToken(PostgreSqlParser.SESSION_USER, i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Reassign_owned_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_reassign_owned_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReassign_owned_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReassign_owned_stmt(this); - } - } - - public final Reassign_owned_stmtContext reassign_owned_stmt() throws RecognitionException { - Reassign_owned_stmtContext _localctx = new Reassign_owned_stmtContext(_ctx, getState()); - enterRule(_localctx, 322, RULE_reassign_owned_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3769); - match(REASSIGN); - setState(3770); - match(OWNED); - setState(3771); - match(BY); - { - setState(3775); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(3772); - identifier(0); - } - break; - case CURRENT_USER: - { - setState(3773); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(3774); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - setState(3785); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(3777); - match(COMMA); - setState(3781); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(3778); - identifier(0); - } - break; - case CURRENT_USER: - { - setState(3779); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(3780); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(3787); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - setState(3788); - match(TO); - setState(3792); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(3789); - identifier(0); - } - break; - case CURRENT_USER: - { - setState(3790); - match(CURRENT_USER); - } - break; - case SESSION_USER: - { - setState(3791); - match(SESSION_USER); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Refresh_materialized_view_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Refresh_materialized_view_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_refresh_materialized_view_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRefresh_materialized_view_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRefresh_materialized_view_stmt(this); - } - } - - public final Refresh_materialized_view_stmtContext refresh_materialized_view_stmt() throws RecognitionException { - Refresh_materialized_view_stmtContext _localctx = new Refresh_materialized_view_stmtContext(_ctx, getState()); - enterRule(_localctx, 324, RULE_refresh_materialized_view_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3794); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Reindex_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode REINDEX() { return getToken(PostgreSqlParser.REINDEX, 0); } - public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } - public TerminalNode SYSTEM() { return getToken(PostgreSqlParser.SYSTEM, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Reindex_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_reindex_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReindex_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReindex_stmt(this); - } - } - - public final Reindex_stmtContext reindex_stmt() throws RecognitionException { - Reindex_stmtContext _localctx = new Reindex_stmtContext(_ctx, getState()); - enterRule(_localctx, 326, RULE_reindex_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3796); - match(REINDEX); - setState(3800); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(3797); - match(OPEN_PAREN); - setState(3798); - match(VERBOSE); - setState(3799); - match(CLOSE_PAREN); - } - } - - setState(3802); - _la = _input.LA(1); - if ( !(_la==DATABASE || _la==INDEX || _la==SCHEMA || _la==SYSTEM || _la==TABLE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(3803); - ((Reindex_stmtContext)_localctx).name = identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Release_savepoint_stmtContext extends ParserRuleContext { - public IdentifierContext savepoint_name; - public TerminalNode RELEASE() { return getToken(PostgreSqlParser.RELEASE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode SAVEPOINT() { return getToken(PostgreSqlParser.SAVEPOINT, 0); } - public Release_savepoint_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_release_savepoint_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRelease_savepoint_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRelease_savepoint_stmt(this); - } - } - - public final Release_savepoint_stmtContext release_savepoint_stmt() throws RecognitionException { - Release_savepoint_stmtContext _localctx = new Release_savepoint_stmtContext(_ctx, getState()); - enterRule(_localctx, 328, RULE_release_savepoint_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3805); - match(RELEASE); - setState(3807); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,399,_ctx) ) { - case 1: - { - setState(3806); - match(SAVEPOINT); - } - break; - } - setState(3809); - ((Release_savepoint_stmtContext)_localctx).savepoint_name = identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Reset_stmtContext extends ParserRuleContext { - public IdentifierContext configuration_parameter; - public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Reset_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_reset_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReset_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReset_stmt(this); - } - } - - public final Reset_stmtContext reset_stmt() throws RecognitionException { - Reset_stmtContext _localctx = new Reset_stmtContext(_ctx, getState()); - enterRule(_localctx, 330, RULE_reset_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3811); - match(RESET); - setState(3814); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(3812); - ((Reset_stmtContext)_localctx).configuration_parameter = identifier(0); - } - break; - case ALL: - { - setState(3813); - match(ALL); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Revoke_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Revoke_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_revoke_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRevoke_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRevoke_stmt(this); - } - } - - public final Revoke_stmtContext revoke_stmt() throws RecognitionException { - Revoke_stmtContext _localctx = new Revoke_stmtContext(_ctx, getState()); - enterRule(_localctx, 332, RULE_revoke_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3816); - todo_implement(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Rollback_stmtContext extends ParserRuleContext { - public TerminalNode ROLLBACK() { return getToken(PostgreSqlParser.ROLLBACK, 0); } - public TerminalNode WORK() { return getToken(PostgreSqlParser.WORK, 0); } - public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } - public Rollback_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_rollback_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRollback_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRollback_stmt(this); - } - } - - public final Rollback_stmtContext rollback_stmt() throws RecognitionException { - Rollback_stmtContext _localctx = new Rollback_stmtContext(_ctx, getState()); - enterRule(_localctx, 334, RULE_rollback_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3818); - match(ROLLBACK); - setState(3820); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TRANSACTION || _la==WORK) { - { - setState(3819); - _la = _input.LA(1); - if ( !(_la==TRANSACTION || _la==WORK) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Rollback_prepared_stmtContext extends ParserRuleContext { - public Token transaction_id; - public TerminalNode ROLLBACK() { return getToken(PostgreSqlParser.ROLLBACK, 0); } - public TerminalNode PREPARED() { return getToken(PostgreSqlParser.PREPARED, 0); } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public Rollback_prepared_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_rollback_prepared_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRollback_prepared_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRollback_prepared_stmt(this); - } - } - - public final Rollback_prepared_stmtContext rollback_prepared_stmt() throws RecognitionException { - Rollback_prepared_stmtContext _localctx = new Rollback_prepared_stmtContext(_ctx, getState()); - enterRule(_localctx, 336, RULE_rollback_prepared_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3822); - match(ROLLBACK); - setState(3823); - match(PREPARED); - setState(3824); - ((Rollback_prepared_stmtContext)_localctx).transaction_id = match(INTEGER_LITERAL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Rollback_to_savepoint_stmtContext extends ParserRuleContext { - public IdentifierContext savepoint_name; - public TerminalNode ROLLBACK() { return getToken(PostgreSqlParser.ROLLBACK, 0); } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode SAVEPOINT() { return getToken(PostgreSqlParser.SAVEPOINT, 0); } - public TerminalNode WORK() { return getToken(PostgreSqlParser.WORK, 0); } - public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } - public Rollback_to_savepoint_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_rollback_to_savepoint_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRollback_to_savepoint_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRollback_to_savepoint_stmt(this); - } - } - - public final Rollback_to_savepoint_stmtContext rollback_to_savepoint_stmt() throws RecognitionException { - Rollback_to_savepoint_stmtContext _localctx = new Rollback_to_savepoint_stmtContext(_ctx, getState()); - enterRule(_localctx, 338, RULE_rollback_to_savepoint_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3826); - match(ROLLBACK); - setState(3828); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TRANSACTION || _la==WORK) { - { - setState(3827); - _la = _input.LA(1); - if ( !(_la==TRANSACTION || _la==WORK) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(3830); - match(TO); - setState(3832); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,403,_ctx) ) { - case 1: - { - setState(3831); - match(SAVEPOINT); - } - break; - } - setState(3834); - ((Rollback_to_savepoint_stmtContext)_localctx).savepoint_name = identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Savepoint_stmtContext extends ParserRuleContext { - public IdentifierContext savepoint_name; - public TerminalNode SAVEPOINT() { return getToken(PostgreSqlParser.SAVEPOINT, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Savepoint_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_savepoint_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSavepoint_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSavepoint_stmt(this); - } - } - - public final Savepoint_stmtContext savepoint_stmt() throws RecognitionException { - Savepoint_stmtContext _localctx = new Savepoint_stmtContext(_ctx, getState()); - enterRule(_localctx, 340, RULE_savepoint_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(3836); - match(SAVEPOINT); - setState(3837); - ((Savepoint_stmtContext)_localctx).savepoint_name = identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Security_label_stmtContext extends ParserRuleContext { - public Name_Context provider; - public IdentifierContext object_name; - public IdentifierContext table_name; - public Column_nameContext column_name_; - public IdentifierContext aggregate_name; - public IdentifierContext function_name; - public Token large_object_oid; - public Token label; - public TerminalNode SECURITY() { return getToken(PostgreSqlParser.SECURITY, 0); } - public TerminalNode LABEL() { return getToken(PostgreSqlParser.LABEL, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } - public TerminalNode DOT() { return getToken(PostgreSqlParser.DOT, 0); } - public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Aggregate_signatureContext aggregate_signature() { - return getRuleContext(Aggregate_signatureContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } - public TerminalNode DOMAIN() { return getToken(PostgreSqlParser.DOMAIN, 0); } - public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } - public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } - public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } - public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } - public Func_sigContext func_sig() { - return getRuleContext(Func_sigContext.class,0); - } - public TerminalNode LARGE() { return getToken(PostgreSqlParser.LARGE, 0); } - public TerminalNode OBJECT() { return getToken(PostgreSqlParser.OBJECT, 0); } - public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } - public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } - public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } - public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } - public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } - public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } - public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } - public TerminalNode TYPE() { return getToken(PostgreSqlParser.TYPE, 0); } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Column_nameContext column_name() { - return getRuleContext(Column_nameContext.class,0); - } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode PROCEDURAL() { return getToken(PostgreSqlParser.PROCEDURAL, 0); } - public Security_label_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_security_label_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSecurity_label_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSecurity_label_stmt(this); - } - } - - public final Security_label_stmtContext security_label_stmt() throws RecognitionException { - Security_label_stmtContext _localctx = new Security_label_stmtContext(_ctx, getState()); - enterRule(_localctx, 342, RULE_security_label_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3839); - match(SECURITY); - setState(3840); - match(LABEL); - setState(3843); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FOR) { - { - setState(3841); - match(FOR); - setState(3842); - ((Security_label_stmtContext)_localctx).provider = name_(); - } - } - - setState(3845); - match(ON); - setState(3900); - _errHandler.sync(this); - switch (_input.LA(1)) { - case TABLE: - { - setState(3846); - match(TABLE); - setState(3847); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case COLUMN: - { - setState(3848); - match(COLUMN); - setState(3849); - ((Security_label_stmtContext)_localctx).table_name = identifier(0); - setState(3850); - match(DOT); - setState(3851); - ((Security_label_stmtContext)_localctx).column_name_ = column_name(); - } - break; - case AGGREGATE: - { - setState(3853); - match(AGGREGATE); - setState(3854); - ((Security_label_stmtContext)_localctx).aggregate_name = identifier(0); - setState(3855); - match(OPEN_PAREN); - setState(3856); - aggregate_signature(); - setState(3857); - match(CLOSE_PAREN); - } - break; - case DATABASE: - { - setState(3859); - match(DATABASE); - setState(3860); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case DOMAIN: - { - setState(3861); - match(DOMAIN); - setState(3862); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case EVENT: - { - setState(3863); - match(EVENT); - setState(3864); - match(TRIGGER); - setState(3865); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case FOREIGN: - { - setState(3866); - match(FOREIGN); - setState(3867); - match(TABLE); - setState(3868); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case FUNCTION: - { - setState(3869); - match(FUNCTION); - setState(3870); - ((Security_label_stmtContext)_localctx).function_name = identifier(0); - setState(3871); - func_sig(); - } - break; - case LARGE: - { - setState(3873); - match(LARGE); - setState(3874); - match(OBJECT); - setState(3875); - ((Security_label_stmtContext)_localctx).large_object_oid = match(INTEGER_LITERAL); - } - break; - case MATERIALIZED: - { - setState(3876); - match(MATERIALIZED); - setState(3877); - match(VIEW); - setState(3878); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case LANGUAGE: - case PROCEDURAL: - { - setState(3880); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PROCEDURAL) { - { - setState(3879); - match(PROCEDURAL); - } - } - - setState(3882); - match(LANGUAGE); - setState(3883); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case PUBLICATION: - { - setState(3884); - match(PUBLICATION); - setState(3885); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case ROLE: - { - setState(3886); - match(ROLE); - setState(3887); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case SCHEMA: - { - setState(3888); - match(SCHEMA); - setState(3889); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case SEQUENCE: - { - setState(3890); - match(SEQUENCE); - setState(3891); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case SUBSCRIPTION: - { - setState(3892); - match(SUBSCRIPTION); - setState(3893); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case TABLESPACE: - { - setState(3894); - match(TABLESPACE); - setState(3895); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case TYPE: - { - setState(3896); - match(TYPE); - setState(3897); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - case VIEW: - { - setState(3898); - match(VIEW); - setState(3899); - ((Security_label_stmtContext)_localctx).object_name = identifier(0); - } - break; - default: - throw new NoViableAltException(this); - } - setState(3902); - match(IS); - setState(3903); - ((Security_label_stmtContext)_localctx).label = match(SINGLEQ_STRING_LITERAL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Select_stmtContext extends ParserRuleContext { - public With_clauseContext with_clause() { - return getRuleContext(With_clauseContext.class,0); - } - public Where_clauseContext where_clause() { - return getRuleContext(Where_clauseContext.class,0); - } - public Group_by_clauseContext group_by_clause() { - return getRuleContext(Group_by_clauseContext.class,0); - } - public Having_clauseContext having_clause() { - return getRuleContext(Having_clauseContext.class,0); - } - public Window_clauseContext window_clause() { - return getRuleContext(Window_clauseContext.class,0); - } - public List combine_clause() { - return getRuleContexts(Combine_clauseContext.class); - } - public Combine_clauseContext combine_clause(int i) { - return getRuleContext(Combine_clauseContext.class,i); - } - public Order_by_clauseContext order_by_clause() { - return getRuleContext(Order_by_clauseContext.class,0); - } - public Limit_clauseContext limit_clause() { - return getRuleContext(Limit_clauseContext.class,0); - } - public Offset_clauseContext offset_clause() { - return getRuleContext(Offset_clauseContext.class,0); - } - public Fetch_clauseContext fetch_clause() { - return getRuleContext(Fetch_clauseContext.class,0); - } - public For_clauseContext for_clause() { - return getRuleContext(For_clauseContext.class,0); - } - public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } - public Selector_clauseContext selector_clause() { - return getRuleContext(Selector_clauseContext.class,0); - } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public From_clauseContext from_clause() { - return getRuleContext(From_clauseContext.class,0); - } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public Select_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_select_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_stmt(this); - } - } - - public final Select_stmtContext select_stmt() throws RecognitionException { - Select_stmtContext _localctx = new Select_stmtContext(_ctx, getState()); - enterRule(_localctx, 344, RULE_select_stmt); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3906); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(3905); - with_clause(); - } - } - - setState(3934); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SELECT: - { - { - setState(3908); - match(SELECT); - setState(3909); - selector_clause(); - setState(3911); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,408,_ctx) ) { - case 1: - { - setState(3910); - from_clause(); - } - break; - } - } - } - break; - case TABLE: - { - { - setState(3913); - match(TABLE); - setState(3915); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(3914); - match(ONLY); - } - } - - setState(3917); - table_name_(); - setState(3919); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,410,_ctx) ) { - case 1: - { - setState(3918); - match(STAR); - } - break; - } - } - } - break; - case OPEN_PAREN: - { - { - setState(3922); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(3921); - match(OPEN_PAREN); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3924); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,411,_ctx); - } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); - setState(3926); - select_stmt(); - setState(3928); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(3927); - match(CLOSE_PAREN); - } - } - setState(3930); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==CLOSE_PAREN ); - setState(3932); - combine_clause(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3937); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,414,_ctx) ) { - case 1: - { - setState(3936); - where_clause(); - } - break; - } - setState(3940); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,415,_ctx) ) { - case 1: - { - setState(3939); - group_by_clause(); - } - break; - } - setState(3943); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,416,_ctx) ) { - case 1: - { - setState(3942); - having_clause(); - } - break; - } - setState(3946); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,417,_ctx) ) { - case 1: - { - setState(3945); - window_clause(); - } - break; - } - setState(3949); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,418,_ctx) ) { - case 1: - { - setState(3948); - combine_clause(); - } - break; - } - setState(3952); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,419,_ctx) ) { - case 1: - { - setState(3951); - order_by_clause(); - } - break; - } - setState(3955); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,420,_ctx) ) { - case 1: - { - setState(3954); - limit_clause(); - } - break; - } - setState(3958); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,421,_ctx) ) { - case 1: - { - setState(3957); - offset_clause(); - } - break; - } - setState(3961); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,422,_ctx) ) { - case 1: - { - setState(3960); - fetch_clause(); - } - break; - } - setState(3964); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,423,_ctx) ) { - case 1: - { - setState(3963); - for_clause(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Select_into_stmtContext extends ParserRuleContext { - public Table_name_Context new_table; - public With_clauseContext with_clause() { - return getRuleContext(With_clauseContext.class,0); - } - public Where_clauseContext where_clause() { - return getRuleContext(Where_clauseContext.class,0); - } - public Group_by_clauseContext group_by_clause() { - return getRuleContext(Group_by_clauseContext.class,0); - } - public Having_clauseContext having_clause() { - return getRuleContext(Having_clauseContext.class,0); - } - public Window_clauseContext window_clause() { - return getRuleContext(Window_clauseContext.class,0); - } - public List combine_clause() { - return getRuleContexts(Combine_clauseContext.class); - } - public Combine_clauseContext combine_clause(int i) { - return getRuleContext(Combine_clauseContext.class,i); - } - public Order_by_clauseContext order_by_clause() { - return getRuleContext(Order_by_clauseContext.class,0); - } - public Limit_clauseContext limit_clause() { - return getRuleContext(Limit_clauseContext.class,0); - } - public Offset_clauseContext offset_clause() { - return getRuleContext(Offset_clauseContext.class,0); - } - public Fetch_clauseContext fetch_clause() { - return getRuleContext(Fetch_clauseContext.class,0); - } - public For_clauseContext for_clause() { - return getRuleContext(For_clauseContext.class,0); - } - public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } - public Selector_clauseContext selector_clause() { - return getRuleContext(Selector_clauseContext.class,0); - } - public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public From_clauseContext from_clause() { - return getRuleContext(From_clauseContext.class,0); - } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } - public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } - public TerminalNode UNLOGGED() { return getToken(PostgreSqlParser.UNLOGGED, 0); } - public Select_into_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_select_into_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_into_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_into_stmt(this); - } - } - - public final Select_into_stmtContext select_into_stmt() throws RecognitionException { - Select_into_stmtContext _localctx = new Select_into_stmtContext(_ctx, getState()); - enterRule(_localctx, 346, RULE_select_into_stmt); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3967); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(3966); - with_clause(); - } - } - - setState(4003); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SELECT: - { - { - setState(3969); - match(SELECT); - setState(3970); - selector_clause(); - setState(3971); - match(INTO); - setState(3973); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,425,_ctx) ) { - case 1: - { - setState(3972); - _la = _input.LA(1); - if ( !(((((_la - 571)) & ~0x3f) == 0 && ((1L << (_la - 571)) & 17592186044421L) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(3976); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==TABLE) { - { - setState(3975); - match(TABLE); - } - } - - setState(3978); - ((Select_into_stmtContext)_localctx).new_table = table_name_(); - setState(3980); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FROM) { - { - setState(3979); - from_clause(); - } - } - - } - } - break; - case TABLE: - { - { - setState(3982); - match(TABLE); - setState(3984); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(3983); - match(ONLY); - } - } - - setState(3986); - table_name_(); - setState(3988); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==STAR) { - { - setState(3987); - match(STAR); - } - } - - } - } - break; - case OPEN_PAREN: - { - { - setState(3991); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(3990); - match(OPEN_PAREN); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3993); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,430,_ctx); - } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); - setState(3995); - select_stmt(); - setState(3997); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(3996); - match(CLOSE_PAREN); - } - } - setState(3999); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==CLOSE_PAREN ); - setState(4001); - combine_clause(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(4006); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WHERE) { - { - setState(4005); - where_clause(); - } - } - - setState(4009); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==GROUP) { - { - setState(4008); - group_by_clause(); - } - } - - setState(4012); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==HAVING) { - { - setState(4011); - having_clause(); - } - } - - setState(4015); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WINDOW) { - { - setState(4014); - window_clause(); - } - } - - setState(4018); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==EXCEPT || _la==INTERSECT || _la==UNION) { - { - setState(4017); - combine_clause(); - } - } - - setState(4021); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ORDER) { - { - setState(4020); - order_by_clause(); - } - } - - setState(4024); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LIMIT) { - { - setState(4023); - limit_clause(); - } - } - - setState(4027); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OFFSET) { - { - setState(4026); - offset_clause(); - } - } - - setState(4030); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FETCH) { - { - setState(4029); - fetch_clause(); - } - } - - setState(4033); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FOR) { - { - setState(4032); - for_clause(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class With_clauseContext extends ParserRuleContext { + public static class Opt_withContext extends ParserRuleContext { public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public List with_expr() { - return getRuleContexts(With_exprContext.class); - } - public With_exprContext with_expr(int i) { - return getRuleContext(With_exprContext.class,i); - } - public TerminalNode RECURSIVE() { return getToken(PostgreSqlParser.RECURSIVE, 0); } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public With_clauseContext(ParserRuleContext parent, int invokingState) { + public Opt_withContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_with_clause; } + @Override public int getRuleIndex() { return RULE_opt_with; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWith_clause(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_with(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWith_clause(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_with(this); } } - public final With_clauseContext with_clause() throws RecognitionException { - With_clauseContext _localctx = new With_clauseContext(_ctx, getState()); - enterRule(_localctx, 348, RULE_with_clause); - int _la; + public final Opt_withContext opt_with() throws RecognitionException { + Opt_withContext _localctx = new Opt_withContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_opt_with); try { - enterOuterAlt(_localctx, 1); - { - setState(4035); - match(WITH); - setState(4037); + setState(1784); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,443,_ctx) ) { - case 1: - { - setState(4036); - match(RECURSIVE); - } - break; - } - setState(4039); - with_expr(); - setState(4044); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4040); - match(COMMA); - setState(4041); - with_expr(); - } - } - setState(4046); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class With_exprContext extends ParserRuleContext { - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public Insert_stmtContext insert_stmt() { - return getRuleContext(Insert_stmtContext.class,0); - } - public Delete_stmtContext delete_stmt() { - return getRuleContext(Delete_stmtContext.class,0); - } - public Update_stmtContext update_stmt() { - return getRuleContext(Update_stmtContext.class,0); - } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); - } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public With_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_with_expr; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWith_expr(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWith_expr(this); - } - } - - public final With_exprContext with_expr() throws RecognitionException { - With_exprContext _localctx = new With_exprContext(_ctx, getState()); - enterRule(_localctx, 350, RULE_with_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4047); - table_name_(); - setState(4052); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(4048); - match(OPEN_PAREN); - setState(4049); - name_list(); - setState(4050); - match(CLOSE_PAREN); - } - } - - setState(4054); - match(AS); - setState(4055); - match(OPEN_PAREN); - setState(4061); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,446,_ctx) ) { - case 1: - { - setState(4056); - select_stmt(); - } - break; - case 2: - { - setState(4057); - insert_stmt(); - } - break; - case 3: - { - setState(4058); - delete_stmt(); - } - break; - case 4: - { - setState(4059); - update_stmt(); - } - break; - case 5: - { - setState(4060); - values_stmt(); - } - break; - } - setState(4063); - match(CLOSE_PAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Set_stmtContext extends ParserRuleContext { - public IdentifierContext configuration_parameter; - public Param_valueContext value; - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } - public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } - public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } - public Param_valueContext param_value() { - return getRuleContext(Param_valueContext.class,0); - } - public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } - public List LOCAL() { return getTokens(PostgreSqlParser.LOCAL); } - public TerminalNode LOCAL(int i) { - return getToken(PostgreSqlParser.LOCAL, i); - } - public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } - public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } - public TimezoneContext timezone() { - return getRuleContext(TimezoneContext.class,0); - } - public Set_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_set_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_stmt(this); - } - } - - public final Set_stmtContext set_stmt() throws RecognitionException { - Set_stmtContext _localctx = new Set_stmtContext(_ctx, getState()); - enterRule(_localctx, 352, RULE_set_stmt); - int _la; - try { - setState(4086); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,451,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(4065); - match(SET); - setState(4067); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,447,_ctx) ) { - case 1: - { - setState(4066); - _la = _input.LA(1); - if ( !(_la==LOCAL || _la==SESSION) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(4069); - ((Set_stmtContext)_localctx).configuration_parameter = identifier(0); - setState(4070); - _la = _input.LA(1); - if ( !(_la==TO || _la==EQUAL) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4073); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FALSE: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case ON: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case YES: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case COLON: - case NUMERIC_LITERAL: - case INTEGER_LITERAL: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - case QMARK: - { - setState(4071); - ((Set_stmtContext)_localctx).value = param_value(); - } - break; - case DEFAULT: - { - setState(4072); - match(DEFAULT); - } - break; - default: - throw new NoViableAltException(this); - } + setState(1782); + match(WITH); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(4075); - match(SET); - setState(4077); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LOCAL || _la==SESSION) { - { - setState(4076); - _la = _input.LA(1); - if ( !(_la==LOCAL || _la==SESSION) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(4079); - match(TIME); - setState(4080); - match(ZONE); - setState(4084); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NUMERIC_LITERAL: - case INTEGER_LITERAL: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - { - setState(4081); - timezone(); - } - break; - case LOCAL: - { - setState(4082); - match(LOCAL); - } - break; - case DEFAULT: - { - setState(4083); - match(DEFAULT); - } - break; - default: - throw new NoViableAltException(this); - } } break; } @@ -32009,607 +2569,6029 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Set_constraints_stmtContext extends ParserRuleContext { - public Identifier_listContext constraints; - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode CONSTRAINTS() { return getToken(PostgreSqlParser.CONSTRAINTS, 0); } - public TerminalNode DEFERRED() { return getToken(PostgreSqlParser.DEFERRED, 0); } - public TerminalNode IMMEDIATE() { return getToken(PostgreSqlParser.IMMEDIATE, 0); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); + public static class OptrolelistContext extends ParserRuleContext { + public List createoptroleelem() { + return getRuleContexts(CreateoptroleelemContext.class); } - public Set_constraints_stmtContext(ParserRuleContext parent, int invokingState) { + public CreateoptroleelemContext createoptroleelem(int i) { + return getRuleContext(CreateoptroleelemContext.class,i); + } + public OptrolelistContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_set_constraints_stmt; } + @Override public int getRuleIndex() { return RULE_optrolelist; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_constraints_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptrolelist(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_constraints_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptrolelist(this); } } - public final Set_constraints_stmtContext set_constraints_stmt() throws RecognitionException { - Set_constraints_stmtContext _localctx = new Set_constraints_stmtContext(_ctx, getState()); - enterRule(_localctx, 354, RULE_set_constraints_stmt); - int _la; + public final OptrolelistContext optrolelist() throws RecognitionException { + OptrolelistContext _localctx = new OptrolelistContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_optrolelist); try { + int _alt; enterOuterAlt(_localctx, 1); { - setState(4088); - match(SET); - setState(4089); - match(CONSTRAINTS); - setState(4092); + setState(1789); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,5,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1786); + createoptroleelem(); + } + } + } + setState(1791); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,5,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlteroptrolelistContext extends ParserRuleContext { + public List alteroptroleelem() { + return getRuleContexts(AlteroptroleelemContext.class); + } + public AlteroptroleelemContext alteroptroleelem(int i) { + return getRuleContext(AlteroptroleelemContext.class,i); + } + public AlteroptrolelistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alteroptrolelist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlteroptrolelist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlteroptrolelist(this); + } + } + + public final AlteroptrolelistContext alteroptrolelist() throws RecognitionException { + AlteroptrolelistContext _localctx = new AlteroptrolelistContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_alteroptrolelist); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1795); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,6,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1792); + alteroptroleelem(); + } + } + } + setState(1797); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,6,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlteroptroleelemContext extends ParserRuleContext { + public TerminalNode PASSWORD() { return getToken(PostgreSqlParser.PASSWORD, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode ENCRYPTED() { return getToken(PostgreSqlParser.ENCRYPTED, 0); } + public TerminalNode UNENCRYPTED() { return getToken(PostgreSqlParser.UNENCRYPTED, 0); } + public TerminalNode INHERIT() { return getToken(PostgreSqlParser.INHERIT, 0); } + public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } + public TerminalNode LIMIT() { return getToken(PostgreSqlParser.LIMIT, 0); } + public SignediconstContext signediconst() { + return getRuleContext(SignediconstContext.class,0); + } + public TerminalNode VALID() { return getToken(PostgreSqlParser.VALID, 0); } + public TerminalNode UNTIL() { return getToken(PostgreSqlParser.UNTIL, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AlteroptroleelemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alteroptroleelem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlteroptroleelem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlteroptroleelem(this); + } + } + + public final AlteroptroleelemContext alteroptroleelem() throws RecognitionException { + AlteroptroleelemContext _localctx = new AlteroptroleelemContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_alteroptroleelem); + int _la; + try { + setState(1816); _errHandler.sync(this); switch (_input.LA(1)) { - case ALL: + case PASSWORD: + enterOuterAlt(_localctx, 1); { - setState(4090); - match(ALL); + setState(1798); + match(PASSWORD); + setState(1801); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + { + setState(1799); + sconst(); + } + break; + case NULL_P: + { + setState(1800); + match(NULL_P); + } + break; + default: + throw new NoViableAltException(this); + } } break; - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: + case UNENCRYPTED: + enterOuterAlt(_localctx, 2); + { + setState(1803); + _la = _input.LA(1); + if ( !(_la==ENCRYPTED || _la==UNENCRYPTED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1804); + match(PASSWORD); + setState(1805); + sconst(); + } + break; + case INHERIT: + enterOuterAlt(_localctx, 3); + { + setState(1806); + match(INHERIT); + } + break; + case CONNECTION: + enterOuterAlt(_localctx, 4); + { + setState(1807); + match(CONNECTION); + setState(1808); + match(LIMIT); + setState(1809); + signediconst(); + } + break; + case VALID: + enterOuterAlt(_localctx, 5); + { + setState(1810); + match(VALID); + setState(1811); + match(UNTIL); + setState(1812); + sconst(); + } + break; + case USER: + enterOuterAlt(_localctx, 6); + { + setState(1813); + match(USER); + setState(1814); + role_list(); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case OUTER_P: + case ABSOLUTE_P: + case BACKWARD: + case CHAIN: + case CLOSE: + case COMMIT: + case CONTINUE_P: + case CURSOR: + case FIRST_P: case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: + case LAST_P: case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: case NEXT: case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: + case RELATIVE_P: case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: + case TYPE_P: + case CALL: + case CURRENT_P: + case ROWTYPE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 7); { - setState(4091); - ((Set_constraints_stmtContext)_localctx).constraints = identifier_list(); + setState(1815); + identifier(); } break; default: throw new NoViableAltException(this); } - setState(4094); + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateoptroleelemContext extends ParserRuleContext { + public AlteroptroleelemContext alteroptroleelem() { + return getRuleContext(AlteroptroleelemContext.class,0); + } + public TerminalNode SYSID() { return getToken(PostgreSqlParser.SYSID, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode ADMIN() { return getToken(PostgreSqlParser.ADMIN, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public CreateoptroleelemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createoptroleelem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateoptroleelem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateoptroleelem(this); + } + } + + public final CreateoptroleelemContext createoptroleelem() throws RecognitionException { + CreateoptroleelemContext _localctx = new CreateoptroleelemContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_createoptroleelem); + int _la; + try { + setState(1828); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case USER: + case IS: + case OUTER_P: + case ABSOLUTE_P: + case BACKWARD: + case CHAIN: + case CLOSE: + case COMMIT: + case CONNECTION: + case CONTINUE_P: + case CURSOR: + case ENCRYPTED: + case FIRST_P: + case FORWARD: + case INHERIT: + case INSERT: + case LAST_P: + case MOVE: + case NEXT: + case NO: + case OPTION: + case PASSWORD: + case PRIOR: + case RELATIVE_P: + case RESET: + case ROLLBACK: + case SCHEMA: + case SCROLL: + case SET: + case TYPE_P: + case UNENCRYPTED: + case VALID: + case CALL: + case CURRENT_P: + case ROWTYPE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(1818); + alteroptroleelem(); + } + break; + case SYSID: + enterOuterAlt(_localctx, 2); + { + setState(1819); + match(SYSID); + setState(1820); + iconst(); + } + break; + case ADMIN: + enterOuterAlt(_localctx, 3); + { + setState(1821); + match(ADMIN); + setState(1822); + role_list(); + } + break; + case ROLE: + enterOuterAlt(_localctx, 4); + { + setState(1823); + match(ROLE); + setState(1824); + role_list(); + } + break; + case IN_P: + enterOuterAlt(_localctx, 5); + { + setState(1825); + match(IN_P); + setState(1826); + _la = _input.LA(1); + if ( !(_la==GROUP_P || _la==ROLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1827); + role_list(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateuserstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public RoleidContext roleid() { + return getRuleContext(RoleidContext.class,0); + } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public OptrolelistContext optrolelist() { + return getRuleContext(OptrolelistContext.class,0); + } + public CreateuserstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createuserstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateuserstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateuserstmt(this); + } + } + + public final CreateuserstmtContext createuserstmt() throws RecognitionException { + CreateuserstmtContext _localctx = new CreateuserstmtContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_createuserstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(1830); + match(CREATE); + setState(1831); + match(USER); + setState(1832); + roleid(); + setState(1833); + opt_with(); + setState(1834); + optrolelist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterrolestmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public AlteroptrolelistContext alteroptrolelist() { + return getRuleContext(AlteroptrolelistContext.class,0); + } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public AlterrolestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterrolestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterrolestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterrolestmt(this); + } + } + + public final AlterrolestmtContext alterrolestmt() throws RecognitionException { + AlterrolestmtContext _localctx = new AlterrolestmtContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_alterrolestmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1836); + match(ALTER); + setState(1837); + _la = _input.LA(1); + if ( !(_la==USER || _la==ROLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1838); + rolespec(); + setState(1839); + opt_with(); + setState(1840); + alteroptrolelist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_in_databaseContext extends ParserRuleContext { + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_in_databaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_in_database; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_in_database(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_in_database(this); + } + } + + public final Opt_in_databaseContext opt_in_database() throws RecognitionException { + Opt_in_databaseContext _localctx = new Opt_in_databaseContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_opt_in_database); + try { + setState(1846); + _errHandler.sync(this); + switch (_input.LA(1)) { + case RESET: + case SET: + enterOuterAlt(_localctx, 1); + { + } + break; + case IN_P: + enterOuterAlt(_localctx, 2); + { + setState(1843); + match(IN_P); + setState(1844); + match(DATABASE); + setState(1845); + name(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterrolesetstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public Opt_in_databaseContext opt_in_database() { + return getRuleContext(Opt_in_databaseContext.class,0); + } + public SetresetclauseContext setresetclause() { + return getRuleContext(SetresetclauseContext.class,0); + } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public AlterrolesetstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterrolesetstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterrolesetstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterrolesetstmt(this); + } + } + + public final AlterrolesetstmtContext alterrolesetstmt() throws RecognitionException { + AlterrolesetstmtContext _localctx = new AlterrolesetstmtContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_alterrolesetstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1848); + match(ALTER); + setState(1849); + _la = _input.LA(1); + if ( !(_la==USER || _la==ROLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1851); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL) { + { + setState(1850); + match(ALL); + } + } + + setState(1853); + rolespec(); + setState(1854); + opt_in_database(); + setState(1855); + setresetclause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DroprolestmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public DroprolestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_droprolestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDroprolestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDroprolestmt(this); + } + } + + public final DroprolestmtContext droprolestmt() throws RecognitionException { + DroprolestmtContext _localctx = new DroprolestmtContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_droprolestmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1857); + match(DROP); + setState(1858); + _la = _input.LA(1); + if ( !(_la==GROUP_P || _la==USER || _la==ROLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1861); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { + case 1: + { + setState(1859); + match(IF_P); + setState(1860); + match(EXISTS); + } + break; + } + setState(1863); + role_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreategroupstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public RoleidContext roleid() { + return getRuleContext(RoleidContext.class,0); + } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public OptrolelistContext optrolelist() { + return getRuleContext(OptrolelistContext.class,0); + } + public CreategroupstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_creategroupstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreategroupstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreategroupstmt(this); + } + } + + public final CreategroupstmtContext creategroupstmt() throws RecognitionException { + CreategroupstmtContext _localctx = new CreategroupstmtContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_creategroupstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(1865); + match(CREATE); + setState(1866); + match(GROUP_P); + setState(1867); + roleid(); + setState(1868); + opt_with(); + setState(1869); + optrolelist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltergroupstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public Add_dropContext add_drop() { + return getRuleContext(Add_dropContext.class,0); + } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public AltergroupstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altergroupstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltergroupstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltergroupstmt(this); + } + } + + public final AltergroupstmtContext altergroupstmt() throws RecognitionException { + AltergroupstmtContext _localctx = new AltergroupstmtContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_altergroupstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(1871); + match(ALTER); + setState(1872); + match(GROUP_P); + setState(1873); + rolespec(); + setState(1874); + add_drop(); + setState(1875); + match(USER); + setState(1876); + role_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Add_dropContext extends ParserRuleContext { + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public Add_dropContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_add_drop; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAdd_drop(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAdd_drop(this); + } + } + + public final Add_dropContext add_drop() throws RecognitionException { + Add_dropContext _localctx = new Add_dropContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_add_drop); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1878); + _la = _input.LA(1); + if ( !(_la==ADD_P || _la==DROP) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateschemastmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public OptschemaeltlistContext optschemaeltlist() { + return getRuleContext(OptschemaeltlistContext.class,0); + } + public OptschemanameContext optschemaname() { + return getRuleContext(OptschemanameContext.class,0); + } + public TerminalNode AUTHORIZATION() { return getToken(PostgreSqlParser.AUTHORIZATION, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreateschemastmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createschemastmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateschemastmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateschemastmt(this); + } + } + + public final CreateschemastmtContext createschemastmt() throws RecognitionException { + CreateschemastmtContext _localctx = new CreateschemastmtContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_createschemastmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(1880); + match(CREATE); + setState(1881); + match(SCHEMA); + setState(1885); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { + case 1: + { + setState(1882); + match(IF_P); + setState(1883); + match(NOT); + setState(1884); + match(EXISTS); + } + break; + } + setState(1892); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { + case 1: + { + setState(1887); + optschemaname(); + setState(1888); + match(AUTHORIZATION); + setState(1889); + rolespec(); + } + break; + case 2: + { + setState(1891); + colid(); + } + break; + } + setState(1894); + optschemaeltlist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptschemanameContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public OptschemanameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optschemaname; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptschemaname(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptschemaname(this); + } + } + + public final OptschemanameContext optschemaname() throws RecognitionException { + OptschemanameContext _localctx = new OptschemanameContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_optschemaname); + try { + setState(1898); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(1896); + colid(); + } + break; + case AUTHORIZATION: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptschemaeltlistContext extends ParserRuleContext { + public List schema_stmt() { + return getRuleContexts(Schema_stmtContext.class); + } + public Schema_stmtContext schema_stmt(int i) { + return getRuleContext(Schema_stmtContext.class,i); + } + public OptschemaeltlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optschemaeltlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptschemaeltlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptschemaeltlist(this); + } + } + + public final OptschemaeltlistContext optschemaeltlist() throws RecognitionException { + OptschemaeltlistContext _localctx = new OptschemaeltlistContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_optschemaeltlist); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1903); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,16,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1900); + schema_stmt(); + } + } + } + setState(1905); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,16,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Schema_stmtContext extends ParserRuleContext { + public CreatestmtContext createstmt() { + return getRuleContext(CreatestmtContext.class,0); + } + public IndexstmtContext indexstmt() { + return getRuleContext(IndexstmtContext.class,0); + } + public CreateseqstmtContext createseqstmt() { + return getRuleContext(CreateseqstmtContext.class,0); + } + public CreatetrigstmtContext createtrigstmt() { + return getRuleContext(CreatetrigstmtContext.class,0); + } + public GrantstmtContext grantstmt() { + return getRuleContext(GrantstmtContext.class,0); + } + public ViewstmtContext viewstmt() { + return getRuleContext(ViewstmtContext.class,0); + } + public Schema_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_schema_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSchema_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSchema_stmt(this); + } + } + + public final Schema_stmtContext schema_stmt() throws RecognitionException { + Schema_stmtContext _localctx = new Schema_stmtContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_schema_stmt); + try { + setState(1912); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1906); + createstmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1907); + indexstmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1908); + createseqstmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1909); + createtrigstmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1910); + grantstmt(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1911); + viewstmt(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariablesetstmtContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public Set_restContext set_rest() { + return getRuleContext(Set_restContext.class,0); + } + public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } + public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } + public VariablesetstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variablesetstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVariablesetstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVariablesetstmt(this); + } + } + + public final VariablesetstmtContext variablesetstmt() throws RecognitionException { + VariablesetstmtContext _localctx = new VariablesetstmtContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_variablesetstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1914); + match(SET); + setState(1916); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) { + case 1: + { + setState(1915); + _la = _input.LA(1); + if ( !(_la==LOCAL || _la==SESSION) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(1918); + set_rest(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Set_restContext extends ParserRuleContext { + public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } + public Transaction_mode_listContext transaction_mode_list() { + return getRuleContext(Transaction_mode_listContext.class,0); + } + public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } + public TerminalNode CHARACTERISTICS() { return getToken(PostgreSqlParser.CHARACTERISTICS, 0); } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public Set_rest_moreContext set_rest_more() { + return getRuleContext(Set_rest_moreContext.class,0); + } + public Set_restContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_rest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_rest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_rest(this); + } + } + + public final Set_restContext set_rest() throws RecognitionException { + Set_restContext _localctx = new Set_restContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_set_rest); + try { + setState(1928); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1920); + match(TRANSACTION); + setState(1921); + transaction_mode_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1922); + match(SESSION); + setState(1923); + match(CHARACTERISTICS); + setState(1924); + match(AS); + setState(1925); + match(TRANSACTION); + setState(1926); + transaction_mode_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1927); + set_rest_more(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Generic_setContext extends ParserRuleContext { + public Var_nameContext var_name() { + return getRuleContext(Var_nameContext.class,0); + } + public Var_listContext var_list() { + return getRuleContext(Var_listContext.class,0); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public Generic_setContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generic_set; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGeneric_set(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGeneric_set(this); + } + } + + public final Generic_setContext generic_set() throws RecognitionException { + Generic_setContext _localctx = new Generic_setContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_generic_set); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1930); + var_name(); + setState(1931); + _la = _input.LA(1); + if ( !(_la==EQUAL || _la==TO) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1932); + var_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Set_rest_moreContext extends ParserRuleContext { + public Generic_setContext generic_set() { + return getRuleContext(Generic_setContext.class,0); + } + public Var_nameContext var_name() { + return getRuleContext(Var_nameContext.class,0); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode CURRENT_P() { return getToken(PostgreSqlParser.CURRENT_P, 0); } + public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } + public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } + public Zone_valueContext zone_value() { + return getRuleContext(Zone_valueContext.class,0); + } + public TerminalNode CATALOG() { return getToken(PostgreSqlParser.CATALOG, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode NAMES() { return getToken(PostgreSqlParser.NAMES, 0); } + public Opt_encodingContext opt_encoding() { + return getRuleContext(Opt_encodingContext.class,0); + } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public Nonreservedword_or_sconstContext nonreservedword_or_sconst() { + return getRuleContext(Nonreservedword_or_sconstContext.class,0); + } + public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } + public TerminalNode AUTHORIZATION() { return getToken(PostgreSqlParser.AUTHORIZATION, 0); } + public TerminalNode XML_P() { return getToken(PostgreSqlParser.XML_P, 0); } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public Document_or_contentContext document_or_content() { + return getRuleContext(Document_or_contentContext.class,0); + } + public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } + public TerminalNode SNAPSHOT() { return getToken(PostgreSqlParser.SNAPSHOT, 0); } + public Set_rest_moreContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_rest_more; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_rest_more(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_rest_more(this); + } + } + + public final Set_rest_moreContext set_rest_more() throws RecognitionException { + Set_rest_moreContext _localctx = new Set_rest_moreContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_set_rest_more); + try { + setState(1959); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1934); + generic_set(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1935); + var_name(); + setState(1936); + match(FROM); + setState(1937); + match(CURRENT_P); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1939); + match(TIME); + setState(1940); + match(ZONE); + setState(1941); + zone_value(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1942); + match(CATALOG); + setState(1943); + sconst(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1944); + match(SCHEMA); + setState(1945); + sconst(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1946); + match(NAMES); + setState(1947); + opt_encoding(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1948); + match(ROLE); + setState(1949); + nonreservedword_or_sconst(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1950); + match(SESSION); + setState(1951); + match(AUTHORIZATION); + setState(1952); + nonreservedword_or_sconst(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1953); + match(XML_P); + setState(1954); + match(OPTION); + setState(1955); + document_or_content(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1956); + match(TRANSACTION); + setState(1957); + match(SNAPSHOT); + setState(1958); + sconst(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Var_nameContext extends ParserRuleContext { + public List colid() { + return getRuleContexts(ColidContext.class); + } + public ColidContext colid(int i) { + return getRuleContext(ColidContext.class,i); + } + public List DOT() { return getTokens(PostgreSqlParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(PostgreSqlParser.DOT, i); + } + public Var_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_var_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVar_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVar_name(this); + } + } + + public final Var_nameContext var_name() throws RecognitionException { + Var_nameContext _localctx = new Var_nameContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_var_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1961); + colid(); + setState(1966); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(1962); + match(DOT); + setState(1963); + colid(); + } + } + setState(1968); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Var_listContext extends ParserRuleContext { + public List var_value() { + return getRuleContexts(Var_valueContext.class); + } + public Var_valueContext var_value(int i) { + return getRuleContext(Var_valueContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Var_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_var_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVar_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVar_list(this); + } + } + + public final Var_listContext var_list() throws RecognitionException { + Var_listContext _localctx = new Var_listContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_var_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1969); + var_value(); + setState(1974); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1970); + match(COMMA); + setState(1971); + var_value(); + } + } + setState(1976); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Var_valueContext extends ParserRuleContext { + public Opt_boolean_or_stringContext opt_boolean_or_string() { + return getRuleContext(Opt_boolean_or_stringContext.class,0); + } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public Var_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_var_value; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVar_value(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVar_value(this); + } + } + + public final Var_valueContext var_value() throws RecognitionException { + Var_valueContext _localctx = new Var_valueContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_var_value); + try { + setState(1979); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case ON: + case TABLE: + case TRUE_P: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(1977); + opt_boolean_or_string(); + } + break; + case PLUS: + case MINUS: + case Integral: + case Numeric: + enterOuterAlt(_localctx, 2); + { + setState(1978); + numericonly(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Iso_levelContext extends ParserRuleContext { + public TerminalNode READ() { return getToken(PostgreSqlParser.READ, 0); } + public TerminalNode UNCOMMITTED() { return getToken(PostgreSqlParser.UNCOMMITTED, 0); } + public TerminalNode COMMITTED() { return getToken(PostgreSqlParser.COMMITTED, 0); } + public TerminalNode REPEATABLE() { return getToken(PostgreSqlParser.REPEATABLE, 0); } + public TerminalNode SERIALIZABLE() { return getToken(PostgreSqlParser.SERIALIZABLE, 0); } + public Iso_levelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_iso_level; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIso_level(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIso_level(this); + } + } + + public final Iso_levelContext iso_level() throws RecognitionException { + Iso_levelContext _localctx = new Iso_levelContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_iso_level); + int _la; + try { + setState(1986); + _errHandler.sync(this); + switch (_input.LA(1)) { + case READ: + enterOuterAlt(_localctx, 1); + { + setState(1981); + match(READ); + setState(1982); + _la = _input.LA(1); + if ( !(_la==COMMITTED || _la==UNCOMMITTED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case REPEATABLE: + enterOuterAlt(_localctx, 2); + { + setState(1983); + match(REPEATABLE); + setState(1984); + match(READ); + } + break; + case SERIALIZABLE: + enterOuterAlt(_localctx, 3); + { + setState(1985); + match(SERIALIZABLE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_boolean_or_stringContext extends ParserRuleContext { + public TerminalNode TRUE_P() { return getToken(PostgreSqlParser.TRUE_P, 0); } + public TerminalNode FALSE_P() { return getToken(PostgreSqlParser.FALSE_P, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Nonreservedword_or_sconstContext nonreservedword_or_sconst() { + return getRuleContext(Nonreservedword_or_sconstContext.class,0); + } + public Opt_boolean_or_stringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_boolean_or_string; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_boolean_or_string(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_boolean_or_string(this); + } + } + + public final Opt_boolean_or_stringContext opt_boolean_or_string() throws RecognitionException { + Opt_boolean_or_stringContext _localctx = new Opt_boolean_or_stringContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_opt_boolean_or_string); + try { + setState(1992); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TRUE_P: + enterOuterAlt(_localctx, 1); + { + setState(1988); + match(TRUE_P); + } + break; + case FALSE_P: + enterOuterAlt(_localctx, 2); + { + setState(1989); + match(FALSE_P); + } + break; + case ON: + enterOuterAlt(_localctx, 3); + { + setState(1990); + match(ON); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 4); + { + setState(1991); + nonreservedword_or_sconst(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Zone_valueContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public ConstintervalContext constinterval() { + return getRuleContext(ConstintervalContext.class,0); + } + public Opt_intervalContext opt_interval() { + return getRuleContext(Opt_intervalContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } + public Zone_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_zone_value; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterZone_value(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitZone_value(this); + } + } + + public final Zone_valueContext zone_value() throws RecognitionException { + Zone_valueContext _localctx = new Zone_valueContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_zone_value); + try { + setState(2009); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1994); + sconst(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1995); + identifier(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1996); + constinterval(); + setState(1997); + sconst(); + setState(1998); + opt_interval(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2000); + constinterval(); + setState(2001); + match(OPEN_PAREN); + setState(2002); + iconst(); + setState(2003); + match(CLOSE_PAREN); + setState(2004); + sconst(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2006); + numericonly(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2007); + match(DEFAULT); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2008); + match(LOCAL); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_encodingContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public Opt_encodingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_encoding; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_encoding(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_encoding(this); + } + } + + public final Opt_encodingContext opt_encoding() throws RecognitionException { + Opt_encodingContext _localctx = new Opt_encodingContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_opt_encoding); + try { + setState(2014); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(2011); + sconst(); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 2); + { + setState(2012); + match(DEFAULT); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case AS: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case NOT: + case SELECT: + case TABLE: + case WINDOW: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CALLED: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case COST: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case EXTERNAL: + case IMMUTABLE: + case INSERT: + case LANGUAGE: + case LEAKPROOF: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLLBACK: + case ROWS: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case STABLE: + case START: + case STRICT_P: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VOLATILE: + case VALUES: + case CALL: + case TRANSFORM: + case IMPORT_P: + case END_P: + case SUPPORT: + case PARALLEL: + case MetaCommand: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Nonreservedword_or_sconstContext extends ParserRuleContext { + public NonreservedwordContext nonreservedword() { + return getRuleContext(NonreservedwordContext.class,0); + } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Nonreservedword_or_sconstContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nonreservedword_or_sconst; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNonreservedword_or_sconst(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNonreservedword_or_sconst(this); + } + } + + public final Nonreservedword_or_sconstContext nonreservedword_or_sconst() throws RecognitionException { + Nonreservedword_or_sconstContext _localctx = new Nonreservedword_or_sconstContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_nonreservedword_or_sconst); + try { + setState(2018); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(2016); + nonreservedword(); + } + break; + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 2); + { + setState(2017); + sconst(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableresetstmtContext extends ParserRuleContext { + public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } + public Reset_restContext reset_rest() { + return getRuleContext(Reset_restContext.class,0); + } + public VariableresetstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableresetstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVariableresetstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVariableresetstmt(this); + } + } + + public final VariableresetstmtContext variableresetstmt() throws RecognitionException { + VariableresetstmtContext _localctx = new VariableresetstmtContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_variableresetstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(2020); + match(RESET); + setState(2021); + reset_rest(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Reset_restContext extends ParserRuleContext { + public Generic_resetContext generic_reset() { + return getRuleContext(Generic_resetContext.class,0); + } + public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } + public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } + public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } + public TerminalNode ISOLATION() { return getToken(PostgreSqlParser.ISOLATION, 0); } + public TerminalNode LEVEL() { return getToken(PostgreSqlParser.LEVEL, 0); } + public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } + public TerminalNode AUTHORIZATION() { return getToken(PostgreSqlParser.AUTHORIZATION, 0); } + public Reset_restContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reset_rest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReset_rest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReset_rest(this); + } + } + + public final Reset_restContext reset_rest() throws RecognitionException { + Reset_restContext _localctx = new Reset_restContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_reset_rest); + try { + setState(2031); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2023); + generic_reset(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2024); + match(TIME); + setState(2025); + match(ZONE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2026); + match(TRANSACTION); + setState(2027); + match(ISOLATION); + setState(2028); + match(LEVEL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2029); + match(SESSION); + setState(2030); + match(AUTHORIZATION); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Generic_resetContext extends ParserRuleContext { + public Var_nameContext var_name() { + return getRuleContext(Var_nameContext.class,0); + } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public Generic_resetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generic_reset; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGeneric_reset(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGeneric_reset(this); + } + } + + public final Generic_resetContext generic_reset() throws RecognitionException { + Generic_resetContext _localctx = new Generic_resetContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_generic_reset); + try { + setState(2035); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(2033); + var_name(); + } + break; + case ALL: + enterOuterAlt(_localctx, 2); + { + setState(2034); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetresetclauseContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public Set_restContext set_rest() { + return getRuleContext(Set_restContext.class,0); + } + public VariableresetstmtContext variableresetstmt() { + return getRuleContext(VariableresetstmtContext.class,0); + } + public SetresetclauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_setresetclause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSetresetclause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSetresetclause(this); + } + } + + public final SetresetclauseContext setresetclause() throws RecognitionException { + SetresetclauseContext _localctx = new SetresetclauseContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_setresetclause); + try { + setState(2040); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SET: + enterOuterAlt(_localctx, 1); + { + setState(2037); + match(SET); + setState(2038); + set_rest(); + } + break; + case RESET: + enterOuterAlt(_localctx, 2); + { + setState(2039); + variableresetstmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionsetresetclauseContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public Set_rest_moreContext set_rest_more() { + return getRuleContext(Set_rest_moreContext.class,0); + } + public VariableresetstmtContext variableresetstmt() { + return getRuleContext(VariableresetstmtContext.class,0); + } + public FunctionsetresetclauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionsetresetclause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunctionsetresetclause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunctionsetresetclause(this); + } + } + + public final FunctionsetresetclauseContext functionsetresetclause() throws RecognitionException { + FunctionsetresetclauseContext _localctx = new FunctionsetresetclauseContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_functionsetresetclause); + try { + setState(2045); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SET: + enterOuterAlt(_localctx, 1); + { + setState(2042); + match(SET); + setState(2043); + set_rest_more(); + } + break; + case RESET: + enterOuterAlt(_localctx, 2); + { + setState(2044); + variableresetstmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableshowstmtContext extends ParserRuleContext { + public TerminalNode SHOW() { return getToken(PostgreSqlParser.SHOW, 0); } + public Var_nameContext var_name() { + return getRuleContext(Var_nameContext.class,0); + } + public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } + public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } + public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } + public TerminalNode ISOLATION() { return getToken(PostgreSqlParser.ISOLATION, 0); } + public TerminalNode LEVEL() { return getToken(PostgreSqlParser.LEVEL, 0); } + public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } + public TerminalNode AUTHORIZATION() { return getToken(PostgreSqlParser.AUTHORIZATION, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public VariableshowstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableshowstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVariableshowstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVariableshowstmt(this); + } + } + + public final VariableshowstmtContext variableshowstmt() throws RecognitionException { + VariableshowstmtContext _localctx = new VariableshowstmtContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_variableshowstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(2047); + match(SHOW); + setState(2057); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) { + case 1: + { + setState(2048); + var_name(); + } + break; + case 2: + { + setState(2049); + match(TIME); + setState(2050); + match(ZONE); + } + break; + case 3: + { + setState(2051); + match(TRANSACTION); + setState(2052); + match(ISOLATION); + setState(2053); + match(LEVEL); + } + break; + case 4: + { + setState(2054); + match(SESSION); + setState(2055); + match(AUTHORIZATION); + } + break; + case 5: + { + setState(2056); + match(ALL); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstraintssetstmtContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode CONSTRAINTS() { return getToken(PostgreSqlParser.CONSTRAINTS, 0); } + public Constraints_set_listContext constraints_set_list() { + return getRuleContext(Constraints_set_listContext.class,0); + } + public Constraints_set_modeContext constraints_set_mode() { + return getRuleContext(Constraints_set_modeContext.class,0); + } + public ConstraintssetstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constraintssetstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstraintssetstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstraintssetstmt(this); + } + } + + public final ConstraintssetstmtContext constraintssetstmt() throws RecognitionException { + ConstraintssetstmtContext _localctx = new ConstraintssetstmtContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_constraintssetstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(2059); + match(SET); + setState(2060); + match(CONSTRAINTS); + setState(2061); + constraints_set_list(); + setState(2062); + constraints_set_mode(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Constraints_set_listContext extends ParserRuleContext { + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public Qualified_name_listContext qualified_name_list() { + return getRuleContext(Qualified_name_listContext.class,0); + } + public Constraints_set_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constraints_set_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstraints_set_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstraints_set_list(this); + } + } + + public final Constraints_set_listContext constraints_set_list() throws RecognitionException { + Constraints_set_listContext _localctx = new Constraints_set_listContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_constraints_set_list); + try { + setState(2066); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALL: + enterOuterAlt(_localctx, 1); + { + setState(2064); + match(ALL); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(2065); + qualified_name_list(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Constraints_set_modeContext extends ParserRuleContext { + public TerminalNode DEFERRED() { return getToken(PostgreSqlParser.DEFERRED, 0); } + public TerminalNode IMMEDIATE() { return getToken(PostgreSqlParser.IMMEDIATE, 0); } + public Constraints_set_modeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constraints_set_mode; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstraints_set_mode(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstraints_set_mode(this); + } + } + + public final Constraints_set_modeContext constraints_set_mode() throws RecognitionException { + Constraints_set_modeContext _localctx = new Constraints_set_modeContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_constraints_set_mode); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2068); _la = _input.LA(1); if ( !(_la==DEFERRED || _la==IMMEDIATE) ) { _errHandler.recoverInline(this); @@ -32633,133 +8615,30 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Set_role_stmtContext extends ParserRuleContext { - public Role_nameContext role_name_; - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } - public TerminalNode NONE() { return getToken(PostgreSqlParser.NONE, 0); } - public Role_nameContext role_name() { - return getRuleContext(Role_nameContext.class,0); - } - public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } - public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } - public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } - public Set_role_stmtContext(ParserRuleContext parent, int invokingState) { + public static class CheckpointstmtContext extends ParserRuleContext { + public TerminalNode CHECKPOINT() { return getToken(PostgreSqlParser.CHECKPOINT, 0); } + public CheckpointstmtContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_set_role_stmt; } + @Override public int getRuleIndex() { return RULE_checkpointstmt; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_role_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCheckpointstmt(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_role_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCheckpointstmt(this); } } - public final Set_role_stmtContext set_role_stmt() throws RecognitionException { - Set_role_stmtContext _localctx = new Set_role_stmtContext(_ctx, getState()); - enterRule(_localctx, 356, RULE_set_role_stmt); - int _la; - try { - setState(4107); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SET: - enterOuterAlt(_localctx, 1); - { - setState(4096); - match(SET); - setState(4098); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LOCAL || _la==SESSION) { - { - setState(4097); - _la = _input.LA(1); - if ( !(_la==LOCAL || _la==SESSION) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(4100); - match(ROLE); - setState(4103); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,454,_ctx) ) { - case 1: - { - setState(4101); - ((Set_role_stmtContext)_localctx).role_name_ = role_name(); - } - break; - case 2: - { - setState(4102); - match(NONE); - } - break; - } - } - break; - case RESET: - enterOuterAlt(_localctx, 2); - { - setState(4105); - match(RESET); - setState(4106); - match(ROLE); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Set_session_authorization_stmtContext extends ParserRuleContext { - public Todo_implementContext todo_implement() { - return getRuleContext(Todo_implementContext.class,0); - } - public Set_session_authorization_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_set_session_authorization_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_session_authorization_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_session_authorization_stmt(this); - } - } - - public final Set_session_authorization_stmtContext set_session_authorization_stmt() throws RecognitionException { - Set_session_authorization_stmtContext _localctx = new Set_session_authorization_stmtContext(_ctx, getState()); - enterRule(_localctx, 358, RULE_set_session_authorization_stmt); + public final CheckpointstmtContext checkpointstmt() throws RecognitionException { + CheckpointstmtContext _localctx = new CheckpointstmtContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_checkpointstmt); try { enterOuterAlt(_localctx, 1); { - setState(4109); - todo_implement(); + setState(2070); + match(CHECKPOINT); } } catch (RecognitionException re) { @@ -32774,1312 +8653,39 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Transaction_modeContext extends ParserRuleContext { - public TerminalNode ISOLATION() { return getToken(PostgreSqlParser.ISOLATION, 0); } - public TerminalNode LEVEL() { return getToken(PostgreSqlParser.LEVEL, 0); } - public TerminalNode SERIALIZABLE() { return getToken(PostgreSqlParser.SERIALIZABLE, 0); } - public TerminalNode REPEATABLE() { return getToken(PostgreSqlParser.REPEATABLE, 0); } - public TerminalNode READ() { return getToken(PostgreSqlParser.READ, 0); } - public TerminalNode COMMITTED() { return getToken(PostgreSqlParser.COMMITTED, 0); } - public TerminalNode UNCOMMITTED() { return getToken(PostgreSqlParser.UNCOMMITTED, 0); } - public TerminalNode WRITE() { return getToken(PostgreSqlParser.WRITE, 0); } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode DEFERRABLE() { return getToken(PostgreSqlParser.DEFERRABLE, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public Transaction_modeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_transaction_mode; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransaction_mode(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransaction_mode(this); - } - } - - public final Transaction_modeContext transaction_mode() throws RecognitionException { - Transaction_modeContext _localctx = new Transaction_modeContext(_ctx, getState()); - enterRule(_localctx, 360, RULE_transaction_mode); - int _la; - try { - setState(4130); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,458,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(4111); - match(ISOLATION); - setState(4112); - match(LEVEL); - setState(4120); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,456,_ctx) ) { - case 1: - { - setState(4113); - match(SERIALIZABLE); - } - break; - case 2: - { - setState(4114); - match(REPEATABLE); - setState(4115); - match(READ); - } - break; - case 3: - { - setState(4116); - match(READ); - setState(4117); - match(COMMITTED); - } - break; - case 4: - { - setState(4118); - match(READ); - setState(4119); - match(UNCOMMITTED); - } - break; - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(4122); - match(READ); - setState(4123); - match(WRITE); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(4124); - match(READ); - setState(4125); - match(ONLY); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(4127); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOT) { - { - setState(4126); - match(NOT); - } - } - - setState(4129); - match(DEFERRABLE); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Transaction_mode_listContext extends ParserRuleContext { - public List transaction_mode() { - return getRuleContexts(Transaction_modeContext.class); - } - public Transaction_modeContext transaction_mode(int i) { - return getRuleContext(Transaction_modeContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Transaction_mode_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_transaction_mode_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransaction_mode_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransaction_mode_list(this); - } - } - - public final Transaction_mode_listContext transaction_mode_list() throws RecognitionException { - Transaction_mode_listContext _localctx = new Transaction_mode_listContext(_ctx, getState()); - enterRule(_localctx, 362, RULE_transaction_mode_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4132); - transaction_mode(); - setState(4137); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4133); - match(COMMA); - setState(4134); - transaction_mode(); - } - } - setState(4139); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Set_transaction_stmtContext extends ParserRuleContext { - public Token snapshot_id; - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } - public Transaction_mode_listContext transaction_mode_list() { - return getRuleContext(Transaction_mode_listContext.class,0); - } - public TerminalNode SNAPSHOT() { return getToken(PostgreSqlParser.SNAPSHOT, 0); } - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } - public TerminalNode CHARACTERISTICS() { return getToken(PostgreSqlParser.CHARACTERISTICS, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public Set_transaction_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_set_transaction_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_transaction_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_transaction_stmt(this); - } - } - - public final Set_transaction_stmtContext set_transaction_stmt() throws RecognitionException { - Set_transaction_stmtContext _localctx = new Set_transaction_stmtContext(_ctx, getState()); - enterRule(_localctx, 364, RULE_set_transaction_stmt); - try { - setState(4153); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,460,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(4140); - match(SET); - setState(4141); - match(TRANSACTION); - setState(4142); - transaction_mode_list(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(4143); - match(SET); - setState(4144); - match(TRANSACTION); - setState(4145); - match(SNAPSHOT); - setState(4146); - ((Set_transaction_stmtContext)_localctx).snapshot_id = match(SINGLEQ_STRING_LITERAL); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(4147); - match(SET); - setState(4148); - match(SESSION); - setState(4149); - match(CHARACTERISTICS); - setState(4150); - match(AS); - setState(4151); - match(TRANSACTION); - setState(4152); - transaction_mode_list(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Show_stmtContext extends ParserRuleContext { - public IdentifierContext name; - public TerminalNode SHOW() { return getToken(PostgreSqlParser.SHOW, 0); } - public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } - public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } + public static class DiscardstmtContext extends ParserRuleContext { + public TerminalNode DISCARD() { return getToken(PostgreSqlParser.DISCARD, 0); } public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Show_stmtContext(ParserRuleContext parent, int invokingState) { + public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } + public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } + public TerminalNode PLANS() { return getToken(PostgreSqlParser.PLANS, 0); } + public TerminalNode SEQUENCES() { return getToken(PostgreSqlParser.SEQUENCES, 0); } + public DiscardstmtContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_show_stmt; } + @Override public int getRuleIndex() { return RULE_discardstmt; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterShow_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDiscardstmt(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitShow_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDiscardstmt(this); } } - public final Show_stmtContext show_stmt() throws RecognitionException { - Show_stmtContext _localctx = new Show_stmtContext(_ctx, getState()); - enterRule(_localctx, 366, RULE_show_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(4155); - match(SHOW); - setState(4160); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,461,_ctx) ) { - case 1: - { - setState(4156); - ((Show_stmtContext)_localctx).name = identifier(0); - } - break; - case 2: - { - setState(4157); - match(TIME); - setState(4158); - match(ZONE); - } - break; - case 3: - { - setState(4159); - match(ALL); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Truncate_stmtContext extends ParserRuleContext { - public TerminalNode TRUNCATE() { return getToken(PostgreSqlParser.TRUNCATE, 0); } - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } - public List ONLY() { return getTokens(PostgreSqlParser.ONLY); } - public TerminalNode ONLY(int i) { - return getToken(PostgreSqlParser.ONLY, i); - } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } - public Identifier_listContext identifier_list() { - return getRuleContext(Identifier_listContext.class,0); - } - public TerminalNode IDENTITY() { return getToken(PostgreSqlParser.IDENTITY, 0); } - public TerminalNode RESTART() { return getToken(PostgreSqlParser.RESTART, 0); } - public TerminalNode CONTINUE() { return getToken(PostgreSqlParser.CONTINUE, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public Truncate_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_truncate_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTruncate_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTruncate_stmt(this); - } - } - - public final Truncate_stmtContext truncate_stmt() throws RecognitionException { - Truncate_stmtContext _localctx = new Truncate_stmtContext(_ctx, getState()); - enterRule(_localctx, 368, RULE_truncate_stmt); + public final DiscardstmtContext discardstmt() throws RecognitionException { + DiscardstmtContext _localctx = new DiscardstmtContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_discardstmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(4162); - match(TRUNCATE); - setState(4164); - _errHandler.sync(this); + setState(2072); + match(DISCARD); + setState(2073); _la = _input.LA(1); - if (_la==TABLE) { - { - setState(4163); - match(TABLE); - } - } - - setState(4167); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(4166); - match(ONLY); - } - } - - setState(4169); - table_name_(); - setState(4171); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==STAR) { - { - setState(4170); - match(STAR); - } - } - - setState(4178); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(4173); - match(COMMA); - setState(4175); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(4174); - match(ONLY); - } - } - - setState(4177); - identifier_list(); - } - } - - setState(4182); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CONTINUE || _la==RESTART) { - { - setState(4180); - _la = _input.LA(1); - if ( !(_la==CONTINUE || _la==RESTART) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4181); - match(IDENTITY); - } - } - - setState(4185); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CASCADE || _la==RESTRICT) { - { - setState(4184); - _la = _input.LA(1); - if ( !(_la==CASCADE || _la==RESTRICT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Unlisten_stmtContext extends ParserRuleContext { - public IdentifierContext channel; - public TerminalNode UNLISTEN() { return getToken(PostgreSqlParser.UNLISTEN, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Unlisten_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_unlisten_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUnlisten_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUnlisten_stmt(this); - } - } - - public final Unlisten_stmtContext unlisten_stmt() throws RecognitionException { - Unlisten_stmtContext _localctx = new Unlisten_stmtContext(_ctx, getState()); - enterRule(_localctx, 370, RULE_unlisten_stmt); - try { - enterOuterAlt(_localctx, 1); - { - setState(4187); - match(UNLISTEN); - setState(4190); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(4188); - ((Unlisten_stmtContext)_localctx).channel = identifier(0); - } - break; - case STAR: - { - setState(4189); - match(STAR); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Update_stmtContext extends ParserRuleContext { - public IdentifierContext alias_; - public IdentifierContext cursor_name_; - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public Updater_clauseContext updater_clause() { - return getRuleContext(Updater_clauseContext.class,0); - } - public With_clauseContext with_clause() { - return getRuleContext(With_clauseContext.class,0); - } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public From_clauseContext from_clause() { - return getRuleContext(From_clauseContext.class,0); - } - public Where_clauseContext where_clause() { - return getRuleContext(Where_clauseContext.class,0); - } - public Returning_clauseContext returning_clause() { - return getRuleContext(Returning_clauseContext.class,0); - } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } - public TerminalNode CURRENT() { return getToken(PostgreSqlParser.CURRENT, 0); } - public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public Update_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_update_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUpdate_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUpdate_stmt(this); - } - } - - public final Update_stmtContext update_stmt() throws RecognitionException { - Update_stmtContext _localctx = new Update_stmtContext(_ctx, getState()); - enterRule(_localctx, 372, RULE_update_stmt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4193); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(4192); - with_clause(); - } - } - - setState(4195); - match(UPDATE); - setState(4197); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(4196); - match(ONLY); - } - } - - setState(4199); - table_name_(); - setState(4201); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==STAR) { - { - setState(4200); - match(STAR); - } - } - - setState(4207); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,474,_ctx) ) { - case 1: - { - setState(4204); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(4203); - match(AS); - } - } - - setState(4206); - ((Update_stmtContext)_localctx).alias_ = identifier(0); - } - break; - } - setState(4209); - match(SET); - setState(4210); - updater_clause(); - setState(4212); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FROM) { - { - setState(4211); - from_clause(); - } - } - - setState(4219); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,476,_ctx) ) { - case 1: - { - setState(4214); - where_clause(); - } - break; - case 2: - { - { - setState(4215); - match(WHERE); - setState(4216); - match(CURRENT); - setState(4217); - match(OF); - setState(4218); - ((Update_stmtContext)_localctx).cursor_name_ = identifier(0); - } - } - break; - } - setState(4222); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==RETURNING) { - { - setState(4221); - returning_clause(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Vacuum_optContext extends ParserRuleContext { - public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } - public TerminalNode FREEZE() { return getToken(PostgreSqlParser.FREEZE, 0); } - public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } - public TerminalNode ANALYZE() { return getToken(PostgreSqlParser.ANALYZE, 0); } - public TerminalNode DISABLE_PAGE_SKIPPING() { return getToken(PostgreSqlParser.DISABLE_PAGE_SKIPPING, 0); } - public Vacuum_optContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_vacuum_opt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVacuum_opt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVacuum_opt(this); - } - } - - public final Vacuum_optContext vacuum_opt() throws RecognitionException { - Vacuum_optContext _localctx = new Vacuum_optContext(_ctx, getState()); - enterRule(_localctx, 374, RULE_vacuum_opt); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4224); - _la = _input.LA(1); - if ( !(_la==ANALYZE || ((((_la - 180)) & ~0x3f) == 0 && ((1L << (_la - 180)) & 180143985094819841L) != 0) || _la==VERBOSE) ) { + if ( !(_la==ALL || _la==PLANS || _la==SEQUENCES || _la==TEMP || _la==TEMPORARY) ) { _errHandler.recoverInline(this); } else { @@ -34101,263 +8707,410 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Vacuum_opt_listContext extends ParserRuleContext { - public List vacuum_opt() { - return getRuleContexts(Vacuum_optContext.class); + public static class AltertablestmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Relation_exprContext relation_expr() { + return getRuleContext(Relation_exprContext.class,0); } - public Vacuum_optContext vacuum_opt(int i) { - return getRuleContext(Vacuum_optContext.class,i); + public Alter_table_cmdsContext alter_table_cmds() { + return getRuleContext(Alter_table_cmdsContext.class,0); } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); + public Partition_cmdContext partition_cmd() { + return getRuleContext(Partition_cmdContext.class,0); } - public Vacuum_opt_listContext(ParserRuleContext parent, int invokingState) { + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public List TABLESPACE() { return getTokens(PostgreSqlParser.TABLESPACE); } + public TerminalNode TABLESPACE(int i) { + return getToken(PostgreSqlParser.TABLESPACE, i); + } + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public Opt_nowaitContext opt_nowait() { + return getRuleContext(Opt_nowaitContext.class,0); + } + public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Index_partition_cmdContext index_partition_cmd() { + return getRuleContext(Index_partition_cmdContext.class,0); + } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public AltertablestmtContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_vacuum_opt_list; } + @Override public int getRuleIndex() { return RULE_altertablestmt; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVacuum_opt_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltertablestmt(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVacuum_opt_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltertablestmt(this); } } - public final Vacuum_opt_listContext vacuum_opt_list() throws RecognitionException { - Vacuum_opt_listContext _localctx = new Vacuum_opt_listContext(_ctx, getState()); - enterRule(_localctx, 376, RULE_vacuum_opt_list); + public final AltertablestmtContext altertablestmt() throws RecognitionException { + AltertablestmtContext _localctx = new AltertablestmtContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_altertablestmt); int _la; try { - enterOuterAlt(_localctx, 1); - { - setState(4226); - vacuum_opt(); - setState(4231); + setState(2184); _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4227); - match(COMMA); - setState(4228); - vacuum_opt(); - } - } - setState(4233); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Vacuum_stmtContext extends ParserRuleContext { - public Table_name_Context table_name; - public TerminalNode VACUUM() { return getToken(PostgreSqlParser.VACUUM, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public Vacuum_opt_listContext vacuum_opt_list() { - return getRuleContext(Vacuum_opt_listContext.class,0); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public Column_listContext column_list() { - return getRuleContext(Column_listContext.class,0); - } - public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } - public TerminalNode FREEZE() { return getToken(PostgreSqlParser.FREEZE, 0); } - public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } - public TerminalNode ANALYZE() { return getToken(PostgreSqlParser.ANALYZE, 0); } - public Vacuum_stmtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_vacuum_stmt; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVacuum_stmt(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVacuum_stmt(this); - } - } - - public final Vacuum_stmtContext vacuum_stmt() throws RecognitionException { - Vacuum_stmtContext _localctx = new Vacuum_stmtContext(_ctx, getState()); - enterRule(_localctx, 378, RULE_vacuum_stmt); - int _la; - try { - setState(4281); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,490,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(4234); - match(VACUUM); - setState(4239); + setState(2075); + match(ALTER); + setState(2076); + match(TABLE); + setState(2079); _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { + switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { + case 1: { - setState(4235); - match(OPEN_PAREN); - setState(4236); - vacuum_opt_list(); - setState(4237); - match(CLOSE_PAREN); + setState(2077); + match(IF_P); + setState(2078); + match(EXISTS); } + break; } - - { - setState(4241); - ((Vacuum_stmtContext)_localctx).table_name = table_name_(); - setState(4246); + setState(2081); + relation_expr(); + setState(2084); _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { + switch (_input.LA(1)) { + case NOT: + case ADD_P: + case ALTER: + case CLUSTER: + case DISABLE_P: + case DROP: + case ENABLE_P: + case FORCE: + case INHERIT: + case NO: + case OF: + case OPTIONS: + case OWNER: + case REPLICA: + case RESET: + case SET: + case VALIDATE: { - setState(4242); - match(OPEN_PAREN); - setState(4243); - column_list(); - setState(4244); - match(CLOSE_PAREN); + setState(2082); + alter_table_cmds(); } - } - + break; + case ATTACH: + case DETACH: + { + setState(2083); + partition_cmd(); + } + break; + default: + throw new NoViableAltException(this); } } break; case 2: enterOuterAlt(_localctx, 2); { - setState(4248); - match(VACUUM); - setState(4250); + setState(2086); + match(ALTER); + setState(2087); + match(TABLE); + setState(2088); + match(ALL); + setState(2089); + match(IN_P); + setState(2090); + match(TABLESPACE); + setState(2091); + name(); + setState(2095); _errHandler.sync(this); _la = _input.LA(1); - if (_la==FULL) { + if (_la==OWNED) { { - setState(4249); - match(FULL); - } - } - - setState(4253); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FREEZE) { - { - setState(4252); - match(FREEZE); - } - } - - setState(4256); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==VERBOSE) { - { - setState(4255); - match(VERBOSE); - } - } - - setState(4259); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245456777353L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206585526350118915L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3120954820635131899L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3170536334544601087L) != 0)) { - { - setState(4258); - ((Vacuum_stmtContext)_localctx).table_name = table_name_(); + setState(2092); + match(OWNED); + setState(2093); + match(BY); + setState(2094); + role_list(); } } + setState(2097); + match(SET); + setState(2098); + match(TABLESPACE); + setState(2099); + name(); + setState(2100); + opt_nowait(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(4261); - match(VACUUM); - setState(4263); + setState(2102); + match(ALTER); + setState(2103); + match(INDEX); + setState(2106); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { + case 1: + { + setState(2104); + match(IF_P); + setState(2105); + match(EXISTS); + } + break; + } + setState(2108); + qualified_name(); + setState(2111); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOT: + case ADD_P: + case ALTER: + case CLUSTER: + case DISABLE_P: + case DROP: + case ENABLE_P: + case FORCE: + case INHERIT: + case NO: + case OF: + case OPTIONS: + case OWNER: + case REPLICA: + case RESET: + case SET: + case VALIDATE: + { + setState(2109); + alter_table_cmds(); + } + break; + case ATTACH: + { + setState(2110); + index_partition_cmd(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2113); + match(ALTER); + setState(2114); + match(INDEX); + setState(2115); + match(ALL); + setState(2116); + match(IN_P); + setState(2117); + match(TABLESPACE); + setState(2118); + name(); + setState(2122); _errHandler.sync(this); _la = _input.LA(1); - if (_la==FULL) { + if (_la==OWNED) { { - setState(4262); - match(FULL); + setState(2119); + match(OWNED); + setState(2120); + match(BY); + setState(2121); + role_list(); } } - setState(4266); + setState(2124); + match(SET); + setState(2125); + match(TABLESPACE); + setState(2126); + name(); + setState(2127); + opt_nowait(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2129); + match(ALTER); + setState(2130); + match(SEQUENCE); + setState(2133); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { + case 1: + { + setState(2131); + match(IF_P); + setState(2132); + match(EXISTS); + } + break; + } + setState(2135); + qualified_name(); + setState(2136); + alter_table_cmds(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2138); + match(ALTER); + setState(2139); + match(VIEW); + setState(2142); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { + case 1: + { + setState(2140); + match(IF_P); + setState(2141); + match(EXISTS); + } + break; + } + setState(2144); + qualified_name(); + setState(2145); + alter_table_cmds(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2147); + match(ALTER); + setState(2148); + match(MATERIALIZED); + setState(2149); + match(VIEW); + setState(2152); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { + case 1: + { + setState(2150); + match(IF_P); + setState(2151); + match(EXISTS); + } + break; + } + setState(2154); + qualified_name(); + setState(2155); + alter_table_cmds(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(2157); + match(ALTER); + setState(2158); + match(MATERIALIZED); + setState(2159); + match(VIEW); + setState(2160); + match(ALL); + setState(2161); + match(IN_P); + setState(2162); + match(TABLESPACE); + setState(2163); + name(); + setState(2167); _errHandler.sync(this); _la = _input.LA(1); - if (_la==FREEZE) { + if (_la==OWNED) { { - setState(4265); - match(FREEZE); + setState(2164); + match(OWNED); + setState(2165); + match(BY); + setState(2166); + role_list(); } } - setState(4269); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==VERBOSE) { - { - setState(4268); - match(VERBOSE); - } + setState(2169); + match(SET); + setState(2170); + match(TABLESPACE); + setState(2171); + name(); + setState(2172); + opt_nowait(); } - - setState(4271); - match(ANALYZE); - setState(4279); + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(2174); + match(ALTER); + setState(2175); + match(FOREIGN); + setState(2176); + match(TABLE); + setState(2179); _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245456777353L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206585526350118915L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3120954820635131899L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3170536334544601087L) != 0)) { + switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { + case 1: { - setState(4272); - ((Vacuum_stmtContext)_localctx).table_name = table_name_(); - setState(4277); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(4273); - match(OPEN_PAREN); - setState(4274); - column_list(); - setState(4275); - match(CLOSE_PAREN); - } - } - + setState(2177); + match(IF_P); + setState(2178); + match(EXISTS); } + break; } - + setState(2181); + relation_expr(); + setState(2182); + alter_table_cmds(); } break; } @@ -34374,186 +9127,1989 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Values_stmtContext extends ParserRuleContext { - public With_clauseContext with_clause() { - return getRuleContext(With_clauseContext.class,0); + public static class Alter_table_cmdsContext extends ParserRuleContext { + public List alter_table_cmd() { + return getRuleContexts(Alter_table_cmdContext.class); } - public Order_by_clauseContext order_by_clause() { - return getRuleContext(Order_by_clauseContext.class,0); + public Alter_table_cmdContext alter_table_cmd(int i) { + return getRuleContext(Alter_table_cmdContext.class,i); } - public List combine_clause() { - return getRuleContexts(Combine_clauseContext.class); + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); } - public Combine_clauseContext combine_clause(int i) { - return getRuleContext(Combine_clauseContext.class,i); - } - public Limit_clauseContext limit_clause() { - return getRuleContext(Limit_clauseContext.class,0); - } - public Offset_clauseContext offset_clause() { - return getRuleContext(Offset_clauseContext.class,0); - } - public Fetch_clauseContext fetch_clause() { - return getRuleContext(Fetch_clauseContext.class,0); - } - public TerminalNode VALUES() { return getToken(PostgreSqlParser.VALUES, 0); } - public Expr_list_listContext expr_list_list() { - return getRuleContext(Expr_list_listContext.class,0); - } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); - } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public Values_stmtContext(ParserRuleContext parent, int invokingState) { + public Alter_table_cmdsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_values_stmt; } + @Override public int getRuleIndex() { return RULE_alter_table_cmds; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterValues_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_table_cmds(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitValues_stmt(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_table_cmds(this); } } - public final Values_stmtContext values_stmt() throws RecognitionException { - Values_stmtContext _localctx = new Values_stmtContext(_ctx, getState()); - enterRule(_localctx, 380, RULE_values_stmt); + public final Alter_table_cmdsContext alter_table_cmds() throws RecognitionException { + Alter_table_cmdsContext _localctx = new Alter_table_cmdsContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_alter_table_cmds); int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2186); + alter_table_cmd(); + setState(2191); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2187); + match(COMMA); + setState(2188); + alter_table_cmd(); + } + } + setState(2193); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Partition_cmdContext extends ParserRuleContext { + public TerminalNode ATTACH() { return getToken(PostgreSqlParser.ATTACH, 0); } + public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public PartitionboundspecContext partitionboundspec() { + return getRuleContext(PartitionboundspecContext.class,0); + } + public TerminalNode DETACH() { return getToken(PostgreSqlParser.DETACH, 0); } + public Partition_cmdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partition_cmd; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPartition_cmd(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPartition_cmd(this); + } + } + + public final Partition_cmdContext partition_cmd() throws RecognitionException { + Partition_cmdContext _localctx = new Partition_cmdContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_partition_cmd); + try { + setState(2202); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ATTACH: + enterOuterAlt(_localctx, 1); + { + setState(2194); + match(ATTACH); + setState(2195); + match(PARTITION); + setState(2196); + qualified_name(); + setState(2197); + partitionboundspec(); + } + break; + case DETACH: + enterOuterAlt(_localctx, 2); + { + setState(2199); + match(DETACH); + setState(2200); + match(PARTITION); + setState(2201); + qualified_name(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Index_partition_cmdContext extends ParserRuleContext { + public TerminalNode ATTACH() { return getToken(PostgreSqlParser.ATTACH, 0); } + public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Index_partition_cmdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_index_partition_cmd; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndex_partition_cmd(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndex_partition_cmd(this); + } + } + + public final Index_partition_cmdContext index_partition_cmd() throws RecognitionException { + Index_partition_cmdContext _localctx = new Index_partition_cmdContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_index_partition_cmd); + try { + enterOuterAlt(_localctx, 1); + { + setState(2204); + match(ATTACH); + setState(2205); + match(PARTITION); + setState(2206); + qualified_name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_table_cmdContext extends ParserRuleContext { + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public ColumnDefContext columnDef() { + return getRuleContext(ColumnDefContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public Opt_columnContext opt_column() { + return getRuleContext(Opt_columnContext.class,0); + } + public List colid() { + return getRuleContexts(ColidContext.class); + } + public ColidContext colid(int i) { + return getRuleContext(ColidContext.class,i); + } + public Alter_column_defaultContext alter_column_default() { + return getRuleContext(Alter_column_defaultContext.class,0); + } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode EXPRESSION() { return getToken(PostgreSqlParser.EXPRESSION, 0); } + public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } + public SignediconstContext signediconst() { + return getRuleContext(SignediconstContext.class,0); + } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public ReloptionsContext reloptions() { + return getRuleContext(ReloptionsContext.class,0); + } + public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } + public TerminalNode STORAGE() { return getToken(PostgreSqlParser.STORAGE, 0); } + public TerminalNode GENERATED() { return getToken(PostgreSqlParser.GENERATED, 0); } + public Generated_whenContext generated_when() { + return getRuleContext(Generated_whenContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode IDENTITY_P() { return getToken(PostgreSqlParser.IDENTITY_P, 0); } + public OptparenthesizedseqoptlistContext optparenthesizedseqoptlist() { + return getRuleContext(OptparenthesizedseqoptlistContext.class,0); + } + public Alter_identity_column_option_listContext alter_identity_column_option_list() { + return getRuleContext(Alter_identity_column_option_listContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public Opt_set_dataContext opt_set_data() { + return getRuleContext(Opt_set_dataContext.class,0); + } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public Opt_collate_clauseContext opt_collate_clause() { + return getRuleContext(Opt_collate_clauseContext.class,0); + } + public Alter_usingContext alter_using() { + return getRuleContext(Alter_usingContext.class,0); + } + public Alter_generic_optionsContext alter_generic_options() { + return getRuleContext(Alter_generic_optionsContext.class,0); + } + public TableconstraintContext tableconstraint() { + return getRuleContext(TableconstraintContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public ConstraintattributespecContext constraintattributespec() { + return getRuleContext(ConstraintattributespecContext.class,0); + } + public TerminalNode VALIDATE() { return getToken(PostgreSqlParser.VALIDATE, 0); } + public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } + public TerminalNode OIDS() { return getToken(PostgreSqlParser.OIDS, 0); } + public TerminalNode CLUSTER() { return getToken(PostgreSqlParser.CLUSTER, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public TerminalNode LOGGED() { return getToken(PostgreSqlParser.LOGGED, 0); } + public TerminalNode UNLOGGED() { return getToken(PostgreSqlParser.UNLOGGED, 0); } + public TerminalNode ENABLE_P() { return getToken(PostgreSqlParser.ENABLE_P, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public TerminalNode ALWAYS() { return getToken(PostgreSqlParser.ALWAYS, 0); } + public TerminalNode REPLICA() { return getToken(PostgreSqlParser.REPLICA, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode DISABLE_P() { return getToken(PostgreSqlParser.DISABLE_P, 0); } + public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } + public TerminalNode INHERIT() { return getToken(PostgreSqlParser.INHERIT, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public Replica_identityContext replica_identity() { + return getRuleContext(Replica_identityContext.class,0); + } + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TerminalNode LEVEL() { return getToken(PostgreSqlParser.LEVEL, 0); } + public TerminalNode SECURITY() { return getToken(PostgreSqlParser.SECURITY, 0); } + public TerminalNode FORCE() { return getToken(PostgreSqlParser.FORCE, 0); } + public Alter_table_cmdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_table_cmd; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_table_cmd(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_table_cmd(this); + } + } + + public final Alter_table_cmdContext alter_table_cmd() throws RecognitionException { + Alter_table_cmdContext _localctx = new Alter_table_cmdContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_alter_table_cmd); + try { + setState(2460); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2208); + match(ADD_P); + setState(2209); + columnDef(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2210); + match(ADD_P); + setState(2211); + match(IF_P); + setState(2212); + match(NOT); + setState(2213); + match(EXISTS); + setState(2214); + columnDef(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2215); + match(ADD_P); + setState(2216); + match(COLUMN); + setState(2217); + columnDef(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2218); + match(ADD_P); + setState(2219); + match(COLUMN); + setState(2220); + match(IF_P); + setState(2221); + match(NOT); + setState(2222); + match(EXISTS); + setState(2223); + columnDef(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2224); + match(ALTER); + setState(2225); + opt_column(); + setState(2226); + colid(); + setState(2227); + alter_column_default(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2229); + match(ALTER); + setState(2230); + opt_column(); + setState(2231); + colid(); + setState(2232); + match(DROP); + setState(2233); + match(NOT); + setState(2234); + match(NULL_P); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2236); + match(ALTER); + setState(2237); + opt_column(); + setState(2238); + colid(); + setState(2239); + match(SET); + setState(2240); + match(NOT); + setState(2241); + match(NULL_P); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(2243); + match(ALTER); + setState(2244); + opt_column(); + setState(2245); + colid(); + setState(2246); + match(DROP); + setState(2247); + match(EXPRESSION); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(2249); + match(ALTER); + setState(2250); + opt_column(); + setState(2251); + colid(); + setState(2252); + match(DROP); + setState(2253); + match(EXPRESSION); + setState(2254); + match(IF_P); + setState(2255); + match(EXISTS); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(2257); + match(ALTER); + setState(2258); + opt_column(); + setState(2259); + colid(); + setState(2260); + match(SET); + setState(2261); + match(STATISTICS); + setState(2262); + signediconst(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(2264); + match(ALTER); + setState(2265); + opt_column(); + setState(2266); + iconst(); + setState(2267); + match(SET); + setState(2268); + match(STATISTICS); + setState(2269); + signediconst(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(2271); + match(ALTER); + setState(2272); + opt_column(); + setState(2273); + colid(); + setState(2274); + match(SET); + setState(2275); + reloptions(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(2277); + match(ALTER); + setState(2278); + opt_column(); + setState(2279); + colid(); + setState(2280); + match(RESET); + setState(2281); + reloptions(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(2283); + match(ALTER); + setState(2284); + opt_column(); + setState(2285); + colid(); + setState(2286); + match(SET); + setState(2287); + match(STORAGE); + setState(2288); + colid(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(2290); + match(ALTER); + setState(2291); + opt_column(); + setState(2292); + colid(); + setState(2293); + match(ADD_P); + setState(2294); + match(GENERATED); + setState(2295); + generated_when(); + setState(2296); + match(AS); + setState(2297); + match(IDENTITY_P); + setState(2298); + optparenthesizedseqoptlist(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(2300); + match(ALTER); + setState(2301); + opt_column(); + setState(2302); + colid(); + setState(2303); + alter_identity_column_option_list(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(2305); + match(ALTER); + setState(2306); + opt_column(); + setState(2307); + colid(); + setState(2308); + match(DROP); + setState(2309); + match(IDENTITY_P); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(2311); + match(ALTER); + setState(2312); + opt_column(); + setState(2313); + colid(); + setState(2314); + match(DROP); + setState(2315); + match(IDENTITY_P); + setState(2316); + match(IF_P); + setState(2317); + match(EXISTS); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(2319); + match(DROP); + setState(2320); + opt_column(); + setState(2321); + match(IF_P); + setState(2322); + match(EXISTS); + setState(2323); + colid(); + setState(2324); + opt_drop_behavior(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(2326); + match(DROP); + setState(2327); + opt_column(); + setState(2328); + colid(); + setState(2329); + opt_drop_behavior(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(2331); + match(ALTER); + setState(2332); + opt_column(); + setState(2333); + colid(); + setState(2334); + opt_set_data(); + setState(2335); + match(TYPE_P); + setState(2336); + typename(); + setState(2337); + opt_collate_clause(); + setState(2338); + alter_using(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(2340); + match(ALTER); + setState(2341); + opt_column(); + setState(2342); + colid(); + setState(2343); + alter_generic_options(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(2345); + match(ADD_P); + setState(2346); + tableconstraint(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(2347); + match(ALTER); + setState(2348); + match(CONSTRAINT); + setState(2349); + name(); + setState(2350); + constraintattributespec(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(2352); + match(VALIDATE); + setState(2353); + match(CONSTRAINT); + setState(2354); + name(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(2355); + match(DROP); + setState(2356); + match(CONSTRAINT); + setState(2357); + match(IF_P); + setState(2358); + match(EXISTS); + setState(2359); + name(); + setState(2360); + opt_drop_behavior(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(2362); + match(DROP); + setState(2363); + match(CONSTRAINT); + setState(2364); + name(); + setState(2365); + opt_drop_behavior(); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(2367); + match(SET); + setState(2368); + match(WITHOUT); + setState(2369); + match(OIDS); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(2370); + match(CLUSTER); + setState(2371); + match(ON); + setState(2372); + name(); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(2373); + match(SET); + setState(2374); + match(WITHOUT); + setState(2375); + match(CLUSTER); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(2376); + match(SET); + setState(2377); + match(LOGGED); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(2378); + match(SET); + setState(2379); + match(UNLOGGED); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(2380); + match(ENABLE_P); + setState(2381); + match(TRIGGER); + setState(2382); + name(); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(2383); + match(ENABLE_P); + setState(2384); + match(ALWAYS); + setState(2385); + match(TRIGGER); + setState(2386); + name(); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(2387); + match(ENABLE_P); + setState(2388); + match(REPLICA); + setState(2389); + match(TRIGGER); + setState(2390); + name(); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(2391); + match(ENABLE_P); + setState(2392); + match(TRIGGER); + setState(2393); + match(ALL); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(2394); + match(ENABLE_P); + setState(2395); + match(TRIGGER); + setState(2396); + match(USER); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(2397); + match(DISABLE_P); + setState(2398); + match(TRIGGER); + setState(2399); + name(); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(2400); + match(DISABLE_P); + setState(2401); + match(TRIGGER); + setState(2402); + match(ALL); + } + break; + case 40: + enterOuterAlt(_localctx, 40); + { + setState(2403); + match(DISABLE_P); + setState(2404); + match(TRIGGER); + setState(2405); + match(USER); + } + break; + case 41: + enterOuterAlt(_localctx, 41); + { + setState(2406); + match(ENABLE_P); + setState(2407); + match(RULE); + setState(2408); + name(); + } + break; + case 42: + enterOuterAlt(_localctx, 42); + { + setState(2409); + match(ENABLE_P); + setState(2410); + match(ALWAYS); + setState(2411); + match(RULE); + setState(2412); + name(); + } + break; + case 43: + enterOuterAlt(_localctx, 43); + { + setState(2413); + match(ENABLE_P); + setState(2414); + match(REPLICA); + setState(2415); + match(RULE); + setState(2416); + name(); + } + break; + case 44: + enterOuterAlt(_localctx, 44); + { + setState(2417); + match(DISABLE_P); + setState(2418); + match(RULE); + setState(2419); + name(); + } + break; + case 45: + enterOuterAlt(_localctx, 45); + { + setState(2420); + match(INHERIT); + setState(2421); + qualified_name(); + } + break; + case 46: + enterOuterAlt(_localctx, 46); + { + setState(2422); + match(NO); + setState(2423); + match(INHERIT); + setState(2424); + qualified_name(); + } + break; + case 47: + enterOuterAlt(_localctx, 47); + { + setState(2425); + match(OF); + setState(2426); + any_name(); + } + break; + case 48: + enterOuterAlt(_localctx, 48); + { + setState(2427); + match(NOT); + setState(2428); + match(OF); + } + break; + case 49: + enterOuterAlt(_localctx, 49); + { + setState(2429); + match(OWNER); + setState(2430); + match(TO); + setState(2431); + rolespec(); + } + break; + case 50: + enterOuterAlt(_localctx, 50); + { + setState(2432); + match(SET); + setState(2433); + match(TABLESPACE); + setState(2434); + name(); + } + break; + case 51: + enterOuterAlt(_localctx, 51); + { + setState(2435); + match(SET); + setState(2436); + reloptions(); + } + break; + case 52: + enterOuterAlt(_localctx, 52); + { + setState(2437); + match(RESET); + setState(2438); + reloptions(); + } + break; + case 53: + enterOuterAlt(_localctx, 53); + { + setState(2439); + match(REPLICA); + setState(2440); + match(IDENTITY_P); + setState(2441); + replica_identity(); + } + break; + case 54: + enterOuterAlt(_localctx, 54); + { + setState(2442); + match(ENABLE_P); + setState(2443); + match(ROW); + setState(2444); + match(LEVEL); + setState(2445); + match(SECURITY); + } + break; + case 55: + enterOuterAlt(_localctx, 55); + { + setState(2446); + match(DISABLE_P); + setState(2447); + match(ROW); + setState(2448); + match(LEVEL); + setState(2449); + match(SECURITY); + } + break; + case 56: + enterOuterAlt(_localctx, 56); + { + setState(2450); + match(FORCE); + setState(2451); + match(ROW); + setState(2452); + match(LEVEL); + setState(2453); + match(SECURITY); + } + break; + case 57: + enterOuterAlt(_localctx, 57); + { + setState(2454); + match(NO); + setState(2455); + match(FORCE); + setState(2456); + match(ROW); + setState(2457); + match(LEVEL); + setState(2458); + match(SECURITY); + } + break; + case 58: + enterOuterAlt(_localctx, 58); + { + setState(2459); + alter_generic_options(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_column_defaultContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public Alter_column_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_column_default; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_column_default(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_column_default(this); + } + } + + public final Alter_column_defaultContext alter_column_default() throws RecognitionException { + Alter_column_defaultContext _localctx = new Alter_column_defaultContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_alter_column_default); + try { + setState(2467); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SET: + enterOuterAlt(_localctx, 1); + { + setState(2462); + match(SET); + setState(2463); + match(DEFAULT); + setState(2464); + a_expr(); + } + break; + case DROP: + enterOuterAlt(_localctx, 2); + { + setState(2465); + match(DROP); + setState(2466); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_drop_behaviorContext extends ParserRuleContext { + public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } + public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } + public Opt_drop_behaviorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_drop_behavior; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_drop_behavior(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_drop_behavior(this); + } + } + + public final Opt_drop_behaviorContext opt_drop_behavior() throws RecognitionException { + Opt_drop_behaviorContext _localctx = new Opt_drop_behaviorContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_opt_drop_behavior); + try { + setState(2472); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CASCADE: + enterOuterAlt(_localctx, 1); + { + setState(2469); + match(CASCADE); + } + break; + case RESTRICT: + enterOuterAlt(_localctx, 2); + { + setState(2470); + match(RESTRICT); + } + break; + case EOF: + case OPEN_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_collate_clauseContext extends ParserRuleContext { + public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Opt_collate_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_collate_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_collate_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_collate_clause(this); + } + } + + public final Opt_collate_clauseContext opt_collate_clause() throws RecognitionException { + Opt_collate_clauseContext _localctx = new Opt_collate_clauseContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_opt_collate_clause); + try { + setState(2477); + _errHandler.sync(this); + switch (_input.LA(1)) { + case COLLATE: + enterOuterAlt(_localctx, 1); + { + setState(2474); + match(COLLATE); + setState(2475); + any_name(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case USING: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CASCADE: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case RESTRICT: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_usingContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Alter_usingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_using; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_using(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_using(this); + } + } + + public final Alter_usingContext alter_using() throws RecognitionException { + Alter_usingContext _localctx = new Alter_usingContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_alter_using); + try { + setState(2482); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(2479); + match(USING); + setState(2480); + a_expr(); + } + break; + case EOF: + case OPEN_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Replica_identityContext extends ParserRuleContext { + public TerminalNode NOTHING() { return getToken(PostgreSqlParser.NOTHING, 0); } + public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Replica_identityContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_replica_identity; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReplica_identity(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReplica_identity(this); + } + } + + public final Replica_identityContext replica_identity() throws RecognitionException { + Replica_identityContext _localctx = new Replica_identityContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_replica_identity); + try { + setState(2490); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOTHING: + enterOuterAlt(_localctx, 1); + { + setState(2484); + match(NOTHING); + } + break; + case FULL: + enterOuterAlt(_localctx, 2); + { + setState(2485); + match(FULL); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 3); + { + setState(2486); + match(DEFAULT); + } + break; + case USING: + enterOuterAlt(_localctx, 4); + { + setState(2487); + match(USING); + setState(2488); + match(INDEX); + setState(2489); + name(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReloptionsContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Reloption_listContext reloption_list() { + return getRuleContext(Reloption_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ReloptionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reloptions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReloptions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReloptions(this); + } + } + + public final ReloptionsContext reloptions() throws RecognitionException { + ReloptionsContext _localctx = new ReloptionsContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_reloptions); + try { + enterOuterAlt(_localctx, 1); + { + setState(2492); + match(OPEN_PAREN); + setState(2493); + reloption_list(); + setState(2494); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_reloptionsContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public ReloptionsContext reloptions() { + return getRuleContext(ReloptionsContext.class,0); + } + public Opt_reloptionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_reloptions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_reloptions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_reloptions(this); + } + } + + public final Opt_reloptionsContext opt_reloptions() throws RecognitionException { + Opt_reloptionsContext _localctx = new Opt_reloptionsContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_opt_reloptions); + try { + setState(2499); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2496); + match(WITH); + setState(2497); + reloptions(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Reloption_listContext extends ParserRuleContext { + public List reloption_elem() { + return getRuleContexts(Reloption_elemContext.class); + } + public Reloption_elemContext reloption_elem(int i) { + return getRuleContext(Reloption_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Reloption_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reloption_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReloption_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReloption_list(this); + } + } + + public final Reloption_listContext reloption_list() throws RecognitionException { + Reloption_listContext _localctx = new Reloption_listContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_reloption_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2501); + reloption_elem(); + setState(2506); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2502); + match(COMMA); + setState(2503); + reloption_elem(); + } + } + setState(2508); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Reloption_elemContext extends ParserRuleContext { + public List collabel() { + return getRuleContexts(CollabelContext.class); + } + public CollabelContext collabel(int i) { + return getRuleContext(CollabelContext.class,i); + } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public Def_argContext def_arg() { + return getRuleContext(Def_argContext.class,0); + } + public TerminalNode DOT() { return getToken(PostgreSqlParser.DOT, 0); } + public Reloption_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reloption_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReloption_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReloption_elem(this); + } + } + + public final Reloption_elemContext reloption_elem() throws RecognitionException { + Reloption_elemContext _localctx = new Reloption_elemContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_reloption_elem); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2509); + collabel(); + setState(2518); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EQUAL: + { + setState(2510); + match(EQUAL); + setState(2511); + def_arg(); + } + break; + case DOT: + { + setState(2512); + match(DOT); + setState(2513); + collabel(); + setState(2516); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL) { + { + setState(2514); + match(EQUAL); + setState(2515); + def_arg(); + } + } + + } + break; + case CLOSE_PAREN: + case COMMA: + break; + default: + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_identity_column_option_listContext extends ParserRuleContext { + public List alter_identity_column_option() { + return getRuleContexts(Alter_identity_column_optionContext.class); + } + public Alter_identity_column_optionContext alter_identity_column_option(int i) { + return getRuleContext(Alter_identity_column_optionContext.class,i); + } + public Alter_identity_column_option_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_identity_column_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_identity_column_option_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_identity_column_option_list(this); + } + } + + public final Alter_identity_column_option_listContext alter_identity_column_option_list() throws RecognitionException { + Alter_identity_column_option_listContext _localctx = new Alter_identity_column_option_listContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_alter_identity_column_option_list); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(4284); + setState(2521); _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(4283); - with_clause(); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(2520); + alter_identity_column_option(); + } + } + break; + default: + throw new NoViableAltException(this); } + setState(2523); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,59,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } - setState(4301); + @SuppressWarnings("CheckReturnValue") + public static class Alter_identity_column_optionContext extends ParserRuleContext { + public TerminalNode RESTART() { return getToken(PostgreSqlParser.RESTART, 0); } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public SeqoptelemContext seqoptelem() { + return getRuleContext(SeqoptelemContext.class,0); + } + public TerminalNode GENERATED() { return getToken(PostgreSqlParser.GENERATED, 0); } + public Generated_whenContext generated_when() { + return getRuleContext(Generated_whenContext.class,0); + } + public Alter_identity_column_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_identity_column_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_identity_column_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_identity_column_option(this); + } + } + + public final Alter_identity_column_optionContext alter_identity_column_option() throws RecognitionException { + Alter_identity_column_optionContext _localctx = new Alter_identity_column_optionContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_alter_identity_column_option); + try { + setState(2537); _errHandler.sync(this); switch (_input.LA(1)) { - case VALUES: + case RESTART: + enterOuterAlt(_localctx, 1); { - { - setState(4286); - match(VALUES); - setState(4287); - expr_list_list(); + setState(2525); + match(RESTART); + setState(2529); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { + case 1: + { + setState(2526); + opt_with(); + setState(2527); + numericonly(); + } + break; } } break; - case OPEN_PAREN: + case SET: + enterOuterAlt(_localctx, 2); { - { - setState(4289); + setState(2531); + match(SET); + setState(2535); _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(4288); - match(OPEN_PAREN); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(4291); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,492,_ctx); - } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); - setState(4293); - values_stmt(); - setState(4295); - _errHandler.sync(this); - _la = _input.LA(1); - do { + switch (_input.LA(1)) { + case AS: + case CACHE: + case CYCLE: + case INCREMENT: + case MAXVALUE: + case MINVALUE: + case NO: + case OWNED: + case RESTART: + case SEQUENCE: + case START: { + setState(2532); + seqoptelem(); + } + break; + case GENERATED: { - setState(4294); - match(CLOSE_PAREN); + setState(2533); + match(GENERATED); + setState(2534); + generated_when(); } - } - setState(4297); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==CLOSE_PAREN ); - setState(4299); - combine_clause(); + break; + default: + throw new NoViableAltException(this); } } break; default: throw new NoViableAltException(this); } - setState(4304); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,495,_ctx) ) { - case 1: - { - setState(4303); - order_by_clause(); - } - break; - } - setState(4307); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,496,_ctx) ) { - case 1: - { - setState(4306); - combine_clause(); - } - break; - } - setState(4310); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,497,_ctx) ) { - case 1: - { - setState(4309); - limit_clause(); - } - break; - } - setState(4313); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,498,_ctx) ) { - case 1: - { - setState(4312); - offset_clause(); - } - break; - } - setState(4316); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,499,_ctx) ) { - case 1: - { - setState(4315); - fetch_clause(); - } - break; - } - } } catch (RecognitionException re) { _localctx.exception = re; @@ -34567,354 +11123,3472 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Selector_clauseContext extends ParserRuleContext { - public Column_listContext column_list() { - return getRuleContext(Column_listContext.class,0); + public static class PartitionboundspecContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode VALUES() { return getToken(PostgreSqlParser.VALUES, 0); } + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } + public TerminalNode OPEN_PAREN(int i) { + return getToken(PostgreSqlParser.OPEN_PAREN, i); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public TerminalNode TOP() { return getToken(PostgreSqlParser.TOP, 0); } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public Expr_listContext expr_list() { - return getRuleContext(Expr_listContext.class,0); + public Hash_partboundContext hash_partbound() { + return getRuleContext(Hash_partboundContext.class,0); } - public Selector_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_selector_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelector_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelector_clause(this); - } - } - - public final Selector_clauseContext selector_clause() throws RecognitionException { - Selector_clauseContext _localctx = new Selector_clauseContext(_ctx, getState()); - enterRule(_localctx, 382, RULE_selector_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4326); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,501,_ctx) ) { - case 1: - { - setState(4318); - match(ALL); - } - break; - case 2: - { - { - setState(4319); - match(DISTINCT); - setState(4322); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ON) { - { - setState(4320); - match(ON); - setState(4321); - expr_list(); - } - } - - } - } - break; - case 3: - { - setState(4324); - match(TOP); - setState(4325); - match(INTEGER_LITERAL); - } - break; - } - setState(4328); - column_list(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class From_clauseContext extends ParserRuleContext { - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public List from_item() { - return getRuleContexts(From_itemContext.class); - } - public From_itemContext from_item(int i) { - return getRuleContext(From_itemContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public From_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_from_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrom_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrom_clause(this); - } - } - - public final From_clauseContext from_clause() throws RecognitionException { - From_clauseContext _localctx = new From_clauseContext(_ctx, getState()); - enterRule(_localctx, 384, RULE_from_clause); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(4330); - match(FROM); - setState(4331); - from_item(0); - setState(4336); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,502,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(4332); - match(COMMA); - setState(4333); - from_item(0); - } - } - } - setState(4338); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,502,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Where_clauseContext extends ParserRuleContext { - public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } - public PredicateContext predicate() { - return getRuleContext(PredicateContext.class,0); - } - public Where_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_where_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWhere_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWhere_clause(this); - } - } - - public final Where_clauseContext where_clause() throws RecognitionException { - Where_clauseContext _localctx = new Where_clauseContext(_ctx, getState()); - enterRule(_localctx, 386, RULE_where_clause); - try { - enterOuterAlt(_localctx, 1); - { - setState(4339); - match(WHERE); - setState(4340); - predicate(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Group_by_clauseContext extends ParserRuleContext { - public TerminalNode GROUP() { return getToken(PostgreSqlParser.GROUP, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public List grouping_elem() { - return getRuleContexts(Grouping_elemContext.class); - } - public Grouping_elemContext grouping_elem(int i) { - return getRuleContext(Grouping_elemContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Group_by_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_group_by_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGroup_by_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGroup_by_clause(this); - } - } - - public final Group_by_clauseContext group_by_clause() throws RecognitionException { - Group_by_clauseContext _localctx = new Group_by_clauseContext(_ctx, getState()); - enterRule(_localctx, 388, RULE_group_by_clause); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(4342); - match(GROUP); - setState(4343); - match(BY); - setState(4344); - grouping_elem(); - setState(4349); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,503,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(4345); - match(COMMA); - setState(4346); - grouping_elem(); - } - } - } - setState(4351); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,503,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Grouping_elemContext extends ParserRuleContext { - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); + public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } + public TerminalNode CLOSE_PAREN(int i) { + return getToken(PostgreSqlParser.CLOSE_PAREN, i); } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } public List expr_list() { return getRuleContexts(Expr_listContext.class); } public Expr_listContext expr_list(int i) { return getRuleContext(Expr_listContext.class,i); } - public TerminalNode ROLLUP() { return getToken(PostgreSqlParser.ROLLUP, 0); } - public TerminalNode CUBE() { return getToken(PostgreSqlParser.CUBE, 0); } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public TerminalNode GROUPING() { return getToken(PostgreSqlParser.GROUPING, 0); } - public TerminalNode SETS() { return getToken(PostgreSqlParser.SETS, 0); } - public Grouping_elem_listContext grouping_elem_list() { - return getRuleContext(Grouping_elem_listContext.class,0); - } - public Grouping_elemContext(ParserRuleContext parent, int invokingState) { + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public PartitionboundspecContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_grouping_elem; } + @Override public int getRuleIndex() { return RULE_partitionboundspec; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrouping_elem(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPartitionboundspec(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrouping_elem(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPartitionboundspec(this); } } - public final Grouping_elemContext grouping_elem() throws RecognitionException { - Grouping_elemContext _localctx = new Grouping_elemContext(_ctx, getState()); - enterRule(_localctx, 390, RULE_grouping_elem); - int _la; + public final PartitionboundspecContext partitionboundspec() throws RecognitionException { + PartitionboundspecContext _localctx = new PartitionboundspecContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_partitionboundspec); try { - setState(4377); + setState(2565); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,507,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(4352); + setState(2539); + match(FOR); + setState(2540); + match(VALUES); + setState(2541); + match(WITH); + setState(2542); match(OPEN_PAREN); - setState(4353); + setState(2543); + hash_partbound(); + setState(2544); match(CLOSE_PAREN); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(4354); - expr(0); + setState(2546); + match(FOR); + setState(2547); + match(VALUES); + setState(2548); + match(IN_P); + setState(2549); + match(OPEN_PAREN); + setState(2550); + expr_list(); + setState(2551); + match(CLOSE_PAREN); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(4355); + setState(2553); + match(FOR); + setState(2554); + match(VALUES); + setState(2555); + match(FROM); + setState(2556); + match(OPEN_PAREN); + setState(2557); expr_list(); + setState(2558); + match(CLOSE_PAREN); + setState(2559); + match(TO); + setState(2560); + match(OPEN_PAREN); + setState(2561); + expr_list(); + setState(2562); + match(CLOSE_PAREN); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(4356); + setState(2564); + match(DEFAULT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Hash_partbound_elemContext extends ParserRuleContext { + public NonreservedwordContext nonreservedword() { + return getRuleContext(NonreservedwordContext.class,0); + } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public Hash_partbound_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hash_partbound_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterHash_partbound_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitHash_partbound_elem(this); + } + } + + public final Hash_partbound_elemContext hash_partbound_elem() throws RecognitionException { + Hash_partbound_elemContext _localctx = new Hash_partbound_elemContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_hash_partbound_elem); + try { + enterOuterAlt(_localctx, 1); + { + setState(2567); + nonreservedword(); + setState(2568); + iconst(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Hash_partboundContext extends ParserRuleContext { + public List hash_partbound_elem() { + return getRuleContexts(Hash_partbound_elemContext.class); + } + public Hash_partbound_elemContext hash_partbound_elem(int i) { + return getRuleContext(Hash_partbound_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Hash_partboundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hash_partbound; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterHash_partbound(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitHash_partbound(this); + } + } + + public final Hash_partboundContext hash_partbound() throws RecognitionException { + Hash_partboundContext _localctx = new Hash_partboundContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_hash_partbound); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2570); + hash_partbound_elem(); + setState(2575); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2571); + match(COMMA); + setState(2572); + hash_partbound_elem(); + } + } + setState(2577); + _errHandler.sync(this); _la = _input.LA(1); - if ( !(_la==CUBE || _la==ROLLUP) ) { + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltercompositetypestmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Alter_type_cmdsContext alter_type_cmds() { + return getRuleContext(Alter_type_cmdsContext.class,0); + } + public AltercompositetypestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altercompositetypestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltercompositetypestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltercompositetypestmt(this); + } + } + + public final AltercompositetypestmtContext altercompositetypestmt() throws RecognitionException { + AltercompositetypestmtContext _localctx = new AltercompositetypestmtContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_altercompositetypestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(2578); + match(ALTER); + setState(2579); + match(TYPE_P); + setState(2580); + any_name(); + setState(2581); + alter_type_cmds(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_type_cmdsContext extends ParserRuleContext { + public List alter_type_cmd() { + return getRuleContexts(Alter_type_cmdContext.class); + } + public Alter_type_cmdContext alter_type_cmd(int i) { + return getRuleContext(Alter_type_cmdContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Alter_type_cmdsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_type_cmds; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_type_cmds(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_type_cmds(this); + } + } + + public final Alter_type_cmdsContext alter_type_cmds() throws RecognitionException { + Alter_type_cmdsContext _localctx = new Alter_type_cmdsContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_alter_type_cmds); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2583); + alter_type_cmd(); + setState(2588); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2584); + match(COMMA); + setState(2585); + alter_type_cmd(); + } + } + setState(2590); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_type_cmdContext extends ParserRuleContext { + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public TerminalNode ATTRIBUTE() { return getToken(PostgreSqlParser.ATTRIBUTE, 0); } + public TablefuncelementContext tablefuncelement() { + return getRuleContext(TablefuncelementContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public Opt_set_dataContext opt_set_data() { + return getRuleContext(Opt_set_dataContext.class,0); + } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public Opt_collate_clauseContext opt_collate_clause() { + return getRuleContext(Opt_collate_clauseContext.class,0); + } + public Alter_type_cmdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_type_cmd; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_type_cmd(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_type_cmd(this); + } + } + + public final Alter_type_cmdContext alter_type_cmd() throws RecognitionException { + Alter_type_cmdContext _localctx = new Alter_type_cmdContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_alter_type_cmd); + try { + setState(2614); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD_P: + enterOuterAlt(_localctx, 1); + { + setState(2591); + match(ADD_P); + setState(2592); + match(ATTRIBUTE); + setState(2593); + tablefuncelement(); + setState(2594); + opt_drop_behavior(); + } + break; + case DROP: + enterOuterAlt(_localctx, 2); + { + setState(2596); + match(DROP); + setState(2597); + match(ATTRIBUTE); + setState(2600); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) { + case 1: + { + setState(2598); + match(IF_P); + setState(2599); + match(EXISTS); + } + break; + } + setState(2602); + colid(); + setState(2603); + opt_drop_behavior(); + } + break; + case ALTER: + enterOuterAlt(_localctx, 3); + { + setState(2605); + match(ALTER); + setState(2606); + match(ATTRIBUTE); + setState(2607); + colid(); + setState(2608); + opt_set_data(); + setState(2609); + match(TYPE_P); + setState(2610); + typename(); + setState(2611); + opt_collate_clause(); + setState(2612); + opt_drop_behavior(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CloseportalstmtContext extends ParserRuleContext { + public TerminalNode CLOSE() { return getToken(PostgreSqlParser.CLOSE, 0); } + public Cursor_nameContext cursor_name() { + return getRuleContext(Cursor_nameContext.class,0); + } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public CloseportalstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_closeportalstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCloseportalstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCloseportalstmt(this); + } + } + + public final CloseportalstmtContext closeportalstmt() throws RecognitionException { + CloseportalstmtContext _localctx = new CloseportalstmtContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_closeportalstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(2616); + match(CLOSE); + setState(2619); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(2617); + cursor_name(); + } + break; + case ALL: + { + setState(2618); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CopystmtContext extends ParserRuleContext { + public TerminalNode COPY() { return getToken(PostgreSqlParser.COPY, 0); } + public Opt_binaryContext opt_binary() { + return getRuleContext(Opt_binaryContext.class,0); + } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Opt_column_listContext opt_column_list() { + return getRuleContext(Opt_column_listContext.class,0); + } + public Copy_fromContext copy_from() { + return getRuleContext(Copy_fromContext.class,0); + } + public Opt_programContext opt_program() { + return getRuleContext(Opt_programContext.class,0); + } + public Copy_file_nameContext copy_file_name() { + return getRuleContext(Copy_file_nameContext.class,0); + } + public Copy_delimiterContext copy_delimiter() { + return getRuleContext(Copy_delimiterContext.class,0); + } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public Copy_optionsContext copy_options() { + return getRuleContext(Copy_optionsContext.class,0); + } + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public PreparablestmtContext preparablestmt() { + return getRuleContext(PreparablestmtContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public CopystmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copystmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopystmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopystmt(this); + } + } + + public final CopystmtContext copystmt() throws RecognitionException { + CopystmtContext _localctx = new CopystmtContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_copystmt); + try { + setState(2643); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2621); + match(COPY); + setState(2622); + opt_binary(); + setState(2623); + qualified_name(); + setState(2624); + opt_column_list(); + setState(2625); + copy_from(); + setState(2626); + opt_program(); + setState(2627); + copy_file_name(); + setState(2628); + copy_delimiter(); + setState(2629); + opt_with(); + setState(2630); + copy_options(); + setState(2631); + where_clause(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2633); + match(COPY); + setState(2634); + match(OPEN_PAREN); + setState(2635); + preparablestmt(); + setState(2636); + match(CLOSE_PAREN); + setState(2637); + match(TO); + setState(2638); + opt_program(); + setState(2639); + copy_file_name(); + setState(2640); + opt_with(); + setState(2641); + copy_options(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_fromContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Copy_fromContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_from; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_from(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_from(this); + } + } + + public final Copy_fromContext copy_from() throws RecognitionException { + Copy_fromContext _localctx = new Copy_fromContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_copy_from); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2645); + _la = _input.LA(1); + if ( !(_la==FROM || _la==TO) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_programContext extends ParserRuleContext { + public TerminalNode PROGRAM() { return getToken(PostgreSqlParser.PROGRAM, 0); } + public Opt_programContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_program; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_program(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_program(this); + } + } + + public final Opt_programContext opt_program() throws RecognitionException { + Opt_programContext _localctx = new Opt_programContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_opt_program); + try { + setState(2649); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PROGRAM: + enterOuterAlt(_localctx, 1); + { + setState(2647); + match(PROGRAM); + } + break; + case STDIN: + case STDOUT: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_file_nameContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode STDIN() { return getToken(PostgreSqlParser.STDIN, 0); } + public TerminalNode STDOUT() { return getToken(PostgreSqlParser.STDOUT, 0); } + public Copy_file_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_file_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_file_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_file_name(this); + } + } + + public final Copy_file_nameContext copy_file_name() throws RecognitionException { + Copy_file_nameContext _localctx = new Copy_file_nameContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_copy_file_name); + try { + setState(2654); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(2651); + sconst(); + } + break; + case STDIN: + enterOuterAlt(_localctx, 2); + { + setState(2652); + match(STDIN); + } + break; + case STDOUT: + enterOuterAlt(_localctx, 3); + { + setState(2653); + match(STDOUT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_optionsContext extends ParserRuleContext { + public Copy_opt_listContext copy_opt_list() { + return getRuleContext(Copy_opt_listContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Copy_generic_opt_listContext copy_generic_opt_list() { + return getRuleContext(Copy_generic_opt_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Copy_optionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_options; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_options(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_options(this); + } + } + + public final Copy_optionsContext copy_options() throws RecognitionException { + Copy_optionsContext _localctx = new Copy_optionsContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_copy_options); + try { + setState(2661); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2656); + copy_opt_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2657); + match(OPEN_PAREN); + setState(2658); + copy_generic_opt_list(); + setState(2659); + match(CLOSE_PAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_opt_listContext extends ParserRuleContext { + public List copy_opt_item() { + return getRuleContexts(Copy_opt_itemContext.class); + } + public Copy_opt_itemContext copy_opt_item(int i) { + return getRuleContext(Copy_opt_itemContext.class,i); + } + public Copy_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_opt_list(this); + } + } + + public final Copy_opt_listContext copy_opt_list() throws RecognitionException { + Copy_opt_listContext _localctx = new Copy_opt_listContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_copy_opt_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2666); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & 17716740097L) != 0) || ((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 35459325497345L) != 0) || _la==QUOTE) { + { + { + setState(2663); + copy_opt_item(); + } + } + setState(2668); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_opt_itemContext extends ParserRuleContext { + public TerminalNode BINARY() { return getToken(PostgreSqlParser.BINARY, 0); } + public TerminalNode FREEZE() { return getToken(PostgreSqlParser.FREEZE, 0); } + public TerminalNode DELIMITER() { return getToken(PostgreSqlParser.DELIMITER, 0); } + public Opt_asContext opt_as() { + return getRuleContext(Opt_asContext.class,0); + } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode CSV() { return getToken(PostgreSqlParser.CSV, 0); } + public TerminalNode HEADER_P() { return getToken(PostgreSqlParser.HEADER_P, 0); } + public TerminalNode QUOTE() { return getToken(PostgreSqlParser.QUOTE, 0); } + public TerminalNode ESCAPE() { return getToken(PostgreSqlParser.ESCAPE, 0); } + public TerminalNode FORCE() { return getToken(PostgreSqlParser.FORCE, 0); } + public ColumnlistContext columnlist() { + return getRuleContext(ColumnlistContext.class,0); + } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode ENCODING() { return getToken(PostgreSqlParser.ENCODING, 0); } + public Copy_opt_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_opt_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_opt_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_opt_item(this); + } + } + + public final Copy_opt_itemContext copy_opt_item() throws RecognitionException { + Copy_opt_itemContext _localctx = new Copy_opt_itemContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_copy_opt_item); + try { + setState(2704); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2669); + match(BINARY); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2670); + match(FREEZE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2671); + match(DELIMITER); + setState(2672); + opt_as(); + setState(2673); + sconst(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2675); + match(NULL_P); + setState(2676); + opt_as(); + setState(2677); + sconst(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2679); + match(CSV); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2680); + match(HEADER_P); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2681); + match(QUOTE); + setState(2682); + opt_as(); + setState(2683); + sconst(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(2685); + match(ESCAPE); + setState(2686); + opt_as(); + setState(2687); + sconst(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(2689); + match(FORCE); + setState(2690); + match(QUOTE); + setState(2691); + columnlist(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(2692); + match(FORCE); + setState(2693); + match(QUOTE); + setState(2694); + match(STAR); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(2695); + match(FORCE); + setState(2696); + match(NOT); + setState(2697); + match(NULL_P); + setState(2698); + columnlist(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(2699); + match(FORCE); + setState(2700); + match(NULL_P); + setState(2701); + columnlist(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(2702); + match(ENCODING); + setState(2703); + sconst(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_binaryContext extends ParserRuleContext { + public TerminalNode BINARY() { return getToken(PostgreSqlParser.BINARY, 0); } + public Opt_binaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_binary; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_binary(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_binary(this); + } + } + + public final Opt_binaryContext opt_binary() throws RecognitionException { + Opt_binaryContext _localctx = new Opt_binaryContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_opt_binary); + try { + setState(2708); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BINARY: + enterOuterAlt(_localctx, 1); + { + setState(2706); + match(BINARY); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_delimiterContext extends ParserRuleContext { + public Opt_usingContext opt_using() { + return getRuleContext(Opt_usingContext.class,0); + } + public TerminalNode DELIMITERS() { return getToken(PostgreSqlParser.DELIMITERS, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Copy_delimiterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_delimiter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_delimiter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_delimiter(this); + } + } + + public final Copy_delimiterContext copy_delimiter() throws RecognitionException { + Copy_delimiterContext _localctx = new Copy_delimiterContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_copy_delimiter); + try { + setState(2715); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + case DELIMITERS: + enterOuterAlt(_localctx, 1); + { + setState(2710); + opt_using(); + setState(2711); + match(DELIMITERS); + setState(2712); + sconst(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case NULL_P: + case SELECT: + case TABLE: + case WHERE: + case WITH: + case BINARY: + case FREEZE: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case CSV: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DELIMITER: + case DISCARD: + case DROP: + case ENCODING: + case ESCAPE: + case EXECUTE: + case EXPLAIN: + case FORCE: + case HEADER_P: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case QUOTE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_usingContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public Opt_usingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_using; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_using(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_using(this); + } + } + + public final Opt_usingContext opt_using() throws RecognitionException { + Opt_usingContext _localctx = new Opt_usingContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_opt_using); + try { + setState(2719); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(2717); + match(USING); + } + break; + case DELIMITERS: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_generic_opt_listContext extends ParserRuleContext { + public List copy_generic_opt_elem() { + return getRuleContexts(Copy_generic_opt_elemContext.class); + } + public Copy_generic_opt_elemContext copy_generic_opt_elem(int i) { + return getRuleContext(Copy_generic_opt_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Copy_generic_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_generic_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_generic_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_generic_opt_list(this); + } + } + + public final Copy_generic_opt_listContext copy_generic_opt_list() throws RecognitionException { + Copy_generic_opt_listContext _localctx = new Copy_generic_opt_listContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_copy_generic_opt_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2721); + copy_generic_opt_elem(); + setState(2726); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2722); + match(COMMA); + setState(2723); + copy_generic_opt_elem(); + } + } + setState(2728); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_generic_opt_elemContext extends ParserRuleContext { + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public Copy_generic_opt_argContext copy_generic_opt_arg() { + return getRuleContext(Copy_generic_opt_argContext.class,0); + } + public Copy_generic_opt_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_generic_opt_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_generic_opt_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_generic_opt_elem(this); + } + } + + public final Copy_generic_opt_elemContext copy_generic_opt_elem() throws RecognitionException { + Copy_generic_opt_elemContext _localctx = new Copy_generic_opt_elemContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_copy_generic_opt_elem); + try { + enterOuterAlt(_localctx, 1); + { + setState(2729); + collabel(); + setState(2730); + copy_generic_opt_arg(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_generic_opt_argContext extends ParserRuleContext { + public Opt_boolean_or_stringContext opt_boolean_or_string() { + return getRuleContext(Opt_boolean_or_stringContext.class,0); + } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Copy_generic_opt_arg_listContext copy_generic_opt_arg_list() { + return getRuleContext(Copy_generic_opt_arg_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Copy_generic_opt_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_generic_opt_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_generic_opt_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_generic_opt_arg(this); + } + } + + public final Copy_generic_opt_argContext copy_generic_opt_arg() throws RecognitionException { + Copy_generic_opt_argContext _localctx = new Copy_generic_opt_argContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_copy_generic_opt_arg); + try { + setState(2740); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case ON: + case TABLE: + case TRUE_P: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(2732); + opt_boolean_or_string(); + } + break; + case PLUS: + case MINUS: + case Integral: + case Numeric: + enterOuterAlt(_localctx, 2); + { + setState(2733); + numericonly(); + } + break; + case STAR: + enterOuterAlt(_localctx, 3); + { + setState(2734); + match(STAR); + } + break; + case OPEN_PAREN: + enterOuterAlt(_localctx, 4); + { + setState(2735); + match(OPEN_PAREN); + setState(2736); + copy_generic_opt_arg_list(); + setState(2737); + match(CLOSE_PAREN); + } + break; + case CLOSE_PAREN: + case COMMA: + enterOuterAlt(_localctx, 5); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_generic_opt_arg_listContext extends ParserRuleContext { + public List copy_generic_opt_arg_list_item() { + return getRuleContexts(Copy_generic_opt_arg_list_itemContext.class); + } + public Copy_generic_opt_arg_list_itemContext copy_generic_opt_arg_list_item(int i) { + return getRuleContext(Copy_generic_opt_arg_list_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Copy_generic_opt_arg_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_generic_opt_arg_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_generic_opt_arg_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_generic_opt_arg_list(this); + } + } + + public final Copy_generic_opt_arg_listContext copy_generic_opt_arg_list() throws RecognitionException { + Copy_generic_opt_arg_listContext _localctx = new Copy_generic_opt_arg_listContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_copy_generic_opt_arg_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2742); + copy_generic_opt_arg_list_item(); + setState(2747); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2743); + match(COMMA); + setState(2744); + copy_generic_opt_arg_list_item(); + } + } + setState(2749); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Copy_generic_opt_arg_list_itemContext extends ParserRuleContext { + public Opt_boolean_or_stringContext opt_boolean_or_string() { + return getRuleContext(Opt_boolean_or_stringContext.class,0); + } + public Copy_generic_opt_arg_list_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_copy_generic_opt_arg_list_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCopy_generic_opt_arg_list_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCopy_generic_opt_arg_list_item(this); + } + } + + public final Copy_generic_opt_arg_list_itemContext copy_generic_opt_arg_list_item() throws RecognitionException { + Copy_generic_opt_arg_list_itemContext _localctx = new Copy_generic_opt_arg_list_itemContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_copy_generic_opt_arg_list_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(2750); + opt_boolean_or_string(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatestmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public OpttempContext opttemp() { + return getRuleContext(OpttempContext.class,0); + } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public List qualified_name() { + return getRuleContexts(Qualified_nameContext.class); + } + public Qualified_nameContext qualified_name(int i) { + return getRuleContext(Qualified_nameContext.class,i); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public OpttableelementlistContext opttableelementlist() { + return getRuleContext(OpttableelementlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public OptinheritContext optinherit() { + return getRuleContext(OptinheritContext.class,0); + } + public OptpartitionspecContext optpartitionspec() { + return getRuleContext(OptpartitionspecContext.class,0); + } + public Table_access_method_clauseContext table_access_method_clause() { + return getRuleContext(Table_access_method_clauseContext.class,0); + } + public OptwithContext optwith() { + return getRuleContext(OptwithContext.class,0); + } + public OncommitoptionContext oncommitoption() { + return getRuleContext(OncommitoptionContext.class,0); + } + public OpttablespaceContext opttablespace() { + return getRuleContext(OpttablespaceContext.class,0); + } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public OpttypedtableelementlistContext opttypedtableelementlist() { + return getRuleContext(OpttypedtableelementlistContext.class,0); + } + public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } + public PartitionboundspecContext partitionboundspec() { + return getRuleContext(PartitionboundspecContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreatestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatestmt(this); + } + } + + public final CreatestmtContext createstmt() throws RecognitionException { + CreatestmtContext _localctx = new CreatestmtContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_createstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(2752); + match(CREATE); + setState(2753); + opttemp(); + setState(2754); + match(TABLE); + setState(2758); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { + case 1: + { + setState(2755); + match(IF_P); + setState(2756); + match(NOT); + setState(2757); + match(EXISTS); + } + break; + } + setState(2760); + qualified_name(); + setState(2791); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + { + setState(2761); + match(OPEN_PAREN); + setState(2762); + opttableelementlist(); + setState(2763); + match(CLOSE_PAREN); + setState(2764); + optinherit(); + setState(2765); + optpartitionspec(); + setState(2766); + table_access_method_clause(); + setState(2767); + optwith(); + setState(2768); + oncommitoption(); + setState(2769); + opttablespace(); + } + break; + case OF: + { + setState(2771); + match(OF); + setState(2772); + any_name(); + setState(2773); + opttypedtableelementlist(); + setState(2774); + optpartitionspec(); + setState(2775); + table_access_method_clause(); + setState(2776); + optwith(); + setState(2777); + oncommitoption(); + setState(2778); + opttablespace(); + } + break; + case PARTITION: + { + setState(2780); + match(PARTITION); + setState(2781); + match(OF); + setState(2782); + qualified_name(); + setState(2783); + opttypedtableelementlist(); + setState(2784); + partitionboundspec(); + setState(2785); + optpartitionspec(); + setState(2786); + table_access_method_clause(); + setState(2787); + optwith(); + setState(2788); + oncommitoption(); + setState(2789); + opttablespace(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OpttempContext extends ParserRuleContext { + public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } + public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } + public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } + public TerminalNode GLOBAL() { return getToken(PostgreSqlParser.GLOBAL, 0); } + public TerminalNode UNLOGGED() { return getToken(PostgreSqlParser.UNLOGGED, 0); } + public OpttempContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opttemp; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpttemp(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpttemp(this); + } + } + + public final OpttempContext opttemp() throws RecognitionException { + OpttempContext _localctx = new OpttempContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_opttemp); + int _la; + try { + setState(2801); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TEMPORARY: + enterOuterAlt(_localctx, 1); + { + setState(2793); + match(TEMPORARY); + } + break; + case TEMP: + enterOuterAlt(_localctx, 2); + { + setState(2794); + match(TEMP); + } + break; + case LOCAL: + enterOuterAlt(_localctx, 3); + { + setState(2795); + match(LOCAL); + setState(2796); + _la = _input.LA(1); + if ( !(_la==TEMP || _la==TEMPORARY) ) { _errHandler.recoverInline(this); } else { @@ -34922,67 +14596,672 @@ public class PostgreSqlParser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(4357); - match(OPEN_PAREN); - setState(4360); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,504,_ctx) ) { - case 1: - { - setState(4358); - expr(0); - } - break; - case 2: - { - setState(4359); - expr_list(); - } - break; } - setState(4369); - _errHandler.sync(this); + break; + case GLOBAL: + enterOuterAlt(_localctx, 4); + { + setState(2797); + match(GLOBAL); + setState(2798); _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4362); - match(COMMA); - setState(4365); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,505,_ctx) ) { - case 1: - { - setState(4363); - expr(0); - } - break; - case 2: - { - setState(4364); - expr_list(); - } - break; - } - } - } - setState(4371); - _errHandler.sync(this); - _la = _input.LA(1); + if ( !(_la==TEMP || _la==TEMPORARY) ) { + _errHandler.recoverInline(this); } - setState(4372); + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case UNLOGGED: + enterOuterAlt(_localctx, 5); + { + setState(2799); + match(UNLOGGED); + } + break; + case TABLE: + case RECURSIVE: + case SEQUENCE: + case VIEW: + enterOuterAlt(_localctx, 6); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OpttableelementlistContext extends ParserRuleContext { + public TableelementlistContext tableelementlist() { + return getRuleContext(TableelementlistContext.class,0); + } + public OpttableelementlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opttableelementlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpttableelementlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpttableelementlist(this); + } + } + + public final OpttableelementlistContext opttableelementlist() throws RecognitionException { + OpttableelementlistContext _localctx = new OpttableelementlistContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_opttableelementlist); + try { + setState(2805); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case CHECK: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case FOREIGN: + case PRIMARY: + case TABLE: + case UNIQUE: + case IS: + case LEFT: + case LIKE: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(2803); + tableelementlist(); + } + break; + case CLOSE_PAREN: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OpttypedtableelementlistContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TypedtableelementlistContext typedtableelementlist() { + return getRuleContext(TypedtableelementlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public OpttypedtableelementlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opttypedtableelementlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpttypedtableelementlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpttypedtableelementlist(this); + } + } + + public final OpttypedtableelementlistContext opttypedtableelementlist() throws RecognitionException { + OpttypedtableelementlistContext _localctx = new OpttypedtableelementlistContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_opttypedtableelementlist); + try { + setState(2812); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2807); + match(OPEN_PAREN); + setState(2808); + typedtableelementlist(); + setState(2809); match(CLOSE_PAREN); } break; - case 5: - enterOuterAlt(_localctx, 5); + case 2: + enterOuterAlt(_localctx, 2); { - setState(4374); - match(GROUPING); - setState(4375); - match(SETS); - setState(4376); - grouping_elem_list(); } break; } @@ -34999,61 +15278,50114 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Grouping_elem_listContext extends ParserRuleContext { - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List grouping_elem() { - return getRuleContexts(Grouping_elemContext.class); + public static class TableelementlistContext extends ParserRuleContext { + public List tableelement() { + return getRuleContexts(TableelementContext.class); } - public Grouping_elemContext grouping_elem(int i) { - return getRuleContext(Grouping_elemContext.class,i); + public TableelementContext tableelement(int i) { + return getRuleContext(TableelementContext.class,i); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(PostgreSqlParser.COMMA, i); } - public Grouping_elem_listContext(ParserRuleContext parent, int invokingState) { + public TableelementlistContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_grouping_elem_list; } + @Override public int getRuleIndex() { return RULE_tableelementlist; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrouping_elem_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTableelementlist(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrouping_elem_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTableelementlist(this); } } - public final Grouping_elem_listContext grouping_elem_list() throws RecognitionException { - Grouping_elem_listContext _localctx = new Grouping_elem_listContext(_ctx, getState()); - enterRule(_localctx, 392, RULE_grouping_elem_list); + public final TableelementlistContext tableelementlist() throws RecognitionException { + TableelementlistContext _localctx = new TableelementlistContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_tableelementlist); int _la; try { enterOuterAlt(_localctx, 1); { - setState(4379); - match(OPEN_PAREN); - setState(4380); - grouping_elem(); - setState(4385); + setState(2814); + tableelement(); + setState(2819); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(4381); + setState(2815); match(COMMA); - setState(4382); - grouping_elem(); + setState(2816); + tableelement(); } } - setState(4387); + setState(2821); _errHandler.sync(this); _la = _input.LA(1); } - setState(4388); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypedtableelementlistContext extends ParserRuleContext { + public List typedtableelement() { + return getRuleContexts(TypedtableelementContext.class); + } + public TypedtableelementContext typedtableelement(int i) { + return getRuleContext(TypedtableelementContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public TypedtableelementlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typedtableelementlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTypedtableelementlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTypedtableelementlist(this); + } + } + + public final TypedtableelementlistContext typedtableelementlist() throws RecognitionException { + TypedtableelementlistContext _localctx = new TypedtableelementlistContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_typedtableelementlist); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2822); + typedtableelement(); + setState(2827); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2823); + match(COMMA); + setState(2824); + typedtableelement(); + } + } + setState(2829); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableelementContext extends ParserRuleContext { + public TableconstraintContext tableconstraint() { + return getRuleContext(TableconstraintContext.class,0); + } + public TablelikeclauseContext tablelikeclause() { + return getRuleContext(TablelikeclauseContext.class,0); + } + public ColumnDefContext columnDef() { + return getRuleContext(ColumnDefContext.class,0); + } + public TableelementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableelement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTableelement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTableelement(this); + } + } + + public final TableelementContext tableelement() throws RecognitionException { + TableelementContext _localctx = new TableelementContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_tableelement); + try { + setState(2833); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2830); + tableconstraint(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2831); + tablelikeclause(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2832); + columnDef(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypedtableelementContext extends ParserRuleContext { + public ColumnOptionsContext columnOptions() { + return getRuleContext(ColumnOptionsContext.class,0); + } + public TableconstraintContext tableconstraint() { + return getRuleContext(TableconstraintContext.class,0); + } + public TypedtableelementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typedtableelement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTypedtableelement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTypedtableelement(this); + } + } + + public final TypedtableelementContext typedtableelement() throws RecognitionException { + TypedtableelementContext _localctx = new TypedtableelementContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_typedtableelement); + try { + setState(2837); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2835); + columnOptions(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2836); + tableconstraint(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColumnDefContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public Create_generic_optionsContext create_generic_options() { + return getRuleContext(Create_generic_optionsContext.class,0); + } + public ColquallistContext colquallist() { + return getRuleContext(ColquallistContext.class,0); + } + public ColumnDefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_columnDef; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumnDef(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumnDef(this); + } + } + + public final ColumnDefContext columnDef() throws RecognitionException { + ColumnDefContext _localctx = new ColumnDefContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_columnDef); + try { + enterOuterAlt(_localctx, 1); + { + setState(2839); + colid(); + setState(2840); + typename(); + setState(2841); + create_generic_options(); + setState(2842); + colquallist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColumnOptionsContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public ColquallistContext colquallist() { + return getRuleContext(ColquallistContext.class,0); + } + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } + public ColumnOptionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_columnOptions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumnOptions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumnOptions(this); + } + } + + public final ColumnOptionsContext columnOptions() throws RecognitionException { + ColumnOptionsContext _localctx = new ColumnOptionsContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_columnOptions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2844); + colid(); + setState(2847); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(2845); + match(WITH); + setState(2846); + match(OPTIONS); + } + } + + setState(2849); + colquallist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColquallistContext extends ParserRuleContext { + public List colconstraint() { + return getRuleContexts(ColconstraintContext.class); + } + public ColconstraintContext colconstraint(int i) { + return getRuleContext(ColconstraintContext.class,i); + } + public ColquallistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_colquallist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColquallist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColquallist(this); + } + } + + public final ColquallistContext colquallist() throws RecognitionException { + ColquallistContext _localctx = new ColquallistContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_colquallist); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2854); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & 72084085530433547L) != 0) || _la==GENERATED) { + { + { + setState(2851); + colconstraint(); + } + } + setState(2856); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColconstraintContext extends ParserRuleContext { + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public ColconstraintelemContext colconstraintelem() { + return getRuleContext(ColconstraintelemContext.class,0); + } + public ConstraintattrContext constraintattr() { + return getRuleContext(ConstraintattrContext.class,0); + } + public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public ColconstraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_colconstraint; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColconstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColconstraint(this); + } + } + + public final ColconstraintContext colconstraint() throws RecognitionException { + ColconstraintContext _localctx = new ColconstraintContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_colconstraint); + try { + setState(2865); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2857); + match(CONSTRAINT); + setState(2858); + name(); + setState(2859); + colconstraintelem(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2861); + colconstraintelem(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2862); + constraintattr(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2863); + match(COLLATE); + setState(2864); + any_name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColconstraintelemContext extends ParserRuleContext { + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode UNIQUE() { return getToken(PostgreSqlParser.UNIQUE, 0); } + public Opt_definitionContext opt_definition() { + return getRuleContext(Opt_definitionContext.class,0); + } + public OptconstablespaceContext optconstablespace() { + return getRuleContext(OptconstablespaceContext.class,0); + } + public TerminalNode PRIMARY() { return getToken(PostgreSqlParser.PRIMARY, 0); } + public TerminalNode KEY() { return getToken(PostgreSqlParser.KEY, 0); } + public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_no_inheritContext opt_no_inherit() { + return getRuleContext(Opt_no_inheritContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public B_exprContext b_expr() { + return getRuleContext(B_exprContext.class,0); + } + public TerminalNode GENERATED() { return getToken(PostgreSqlParser.GENERATED, 0); } + public Generated_whenContext generated_when() { + return getRuleContext(Generated_whenContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode IDENTITY_P() { return getToken(PostgreSqlParser.IDENTITY_P, 0); } + public OptparenthesizedseqoptlistContext optparenthesizedseqoptlist() { + return getRuleContext(OptparenthesizedseqoptlistContext.class,0); + } + public TerminalNode STORED() { return getToken(PostgreSqlParser.STORED, 0); } + public TerminalNode REFERENCES() { return getToken(PostgreSqlParser.REFERENCES, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Opt_column_listContext opt_column_list() { + return getRuleContext(Opt_column_listContext.class,0); + } + public Key_matchContext key_match() { + return getRuleContext(Key_matchContext.class,0); + } + public Key_actionsContext key_actions() { + return getRuleContext(Key_actionsContext.class,0); + } + public ColconstraintelemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_colconstraintelem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColconstraintelem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColconstraintelem(this); + } + } + + public final ColconstraintelemContext colconstraintelem() throws RecognitionException { + ColconstraintelemContext _localctx = new ColconstraintelemContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_colconstraintelem); + try { + setState(2905); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOT: + enterOuterAlt(_localctx, 1); + { + setState(2867); + match(NOT); + setState(2868); + match(NULL_P); + } + break; + case NULL_P: + enterOuterAlt(_localctx, 2); + { + setState(2869); + match(NULL_P); + } + break; + case UNIQUE: + enterOuterAlt(_localctx, 3); + { + setState(2870); + match(UNIQUE); + setState(2871); + opt_definition(); + setState(2872); + optconstablespace(); + } + break; + case PRIMARY: + enterOuterAlt(_localctx, 4); + { + setState(2874); + match(PRIMARY); + setState(2875); + match(KEY); + setState(2876); + opt_definition(); + setState(2877); + optconstablespace(); + } + break; + case CHECK: + enterOuterAlt(_localctx, 5); + { + setState(2879); + match(CHECK); + setState(2880); + match(OPEN_PAREN); + setState(2881); + a_expr(); + setState(2882); + match(CLOSE_PAREN); + setState(2883); + opt_no_inherit(); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 6); + { + setState(2885); + match(DEFAULT); + setState(2886); + b_expr(0); + } + break; + case GENERATED: + enterOuterAlt(_localctx, 7); + { + setState(2887); + match(GENERATED); + setState(2888); + generated_when(); + setState(2889); + match(AS); + setState(2897); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IDENTITY_P: + { + setState(2890); + match(IDENTITY_P); + setState(2891); + optparenthesizedseqoptlist(); + } + break; + case OPEN_PAREN: + { + setState(2892); + match(OPEN_PAREN); + setState(2893); + a_expr(); + setState(2894); + match(CLOSE_PAREN); + setState(2895); + match(STORED); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case REFERENCES: + enterOuterAlt(_localctx, 8); + { + setState(2899); + match(REFERENCES); + setState(2900); + qualified_name(); + setState(2901); + opt_column_list(); + setState(2902); + key_match(); + setState(2903); + key_actions(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Generated_whenContext extends ParserRuleContext { + public TerminalNode ALWAYS() { return getToken(PostgreSqlParser.ALWAYS, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public Generated_whenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generated_when; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGenerated_when(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGenerated_when(this); + } + } + + public final Generated_whenContext generated_when() throws RecognitionException { + Generated_whenContext _localctx = new Generated_whenContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_generated_when); + try { + setState(2910); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALWAYS: + enterOuterAlt(_localctx, 1); + { + setState(2907); + match(ALWAYS); + } + break; + case BY: + enterOuterAlt(_localctx, 2); + { + setState(2908); + match(BY); + setState(2909); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstraintattrContext extends ParserRuleContext { + public TerminalNode DEFERRABLE() { return getToken(PostgreSqlParser.DEFERRABLE, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode INITIALLY() { return getToken(PostgreSqlParser.INITIALLY, 0); } + public TerminalNode DEFERRED() { return getToken(PostgreSqlParser.DEFERRED, 0); } + public TerminalNode IMMEDIATE() { return getToken(PostgreSqlParser.IMMEDIATE, 0); } + public ConstraintattrContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constraintattr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstraintattr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstraintattr(this); + } + } + + public final ConstraintattrContext constraintattr() throws RecognitionException { + ConstraintattrContext _localctx = new ConstraintattrContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_constraintattr); + int _la; + try { + setState(2917); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEFERRABLE: + enterOuterAlt(_localctx, 1); + { + setState(2912); + match(DEFERRABLE); + } + break; + case NOT: + enterOuterAlt(_localctx, 2); + { + setState(2913); + match(NOT); + setState(2914); + match(DEFERRABLE); + } + break; + case INITIALLY: + enterOuterAlt(_localctx, 3); + { + setState(2915); + match(INITIALLY); + setState(2916); + _la = _input.LA(1); + if ( !(_la==DEFERRED || _la==IMMEDIATE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TablelikeclauseContext extends ParserRuleContext { + public TerminalNode LIKE() { return getToken(PostgreSqlParser.LIKE, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TablelikeoptionlistContext tablelikeoptionlist() { + return getRuleContext(TablelikeoptionlistContext.class,0); + } + public TablelikeclauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tablelikeclause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTablelikeclause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTablelikeclause(this); + } + } + + public final TablelikeclauseContext tablelikeclause() throws RecognitionException { + TablelikeclauseContext _localctx = new TablelikeclauseContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_tablelikeclause); + try { + enterOuterAlt(_localctx, 1); + { + setState(2919); + match(LIKE); + setState(2920); + qualified_name(); + setState(2921); + tablelikeoptionlist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TablelikeoptionlistContext extends ParserRuleContext { + public List tablelikeoption() { + return getRuleContexts(TablelikeoptionContext.class); + } + public TablelikeoptionContext tablelikeoption(int i) { + return getRuleContext(TablelikeoptionContext.class,i); + } + public List INCLUDING() { return getTokens(PostgreSqlParser.INCLUDING); } + public TerminalNode INCLUDING(int i) { + return getToken(PostgreSqlParser.INCLUDING, i); + } + public List EXCLUDING() { return getTokens(PostgreSqlParser.EXCLUDING); } + public TerminalNode EXCLUDING(int i) { + return getToken(PostgreSqlParser.EXCLUDING, i); + } + public TablelikeoptionlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tablelikeoptionlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTablelikeoptionlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTablelikeoptionlist(this); + } + } + + public final TablelikeoptionlistContext tablelikeoptionlist() throws RecognitionException { + TablelikeoptionlistContext _localctx = new TablelikeoptionlistContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_tablelikeoptionlist); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2927); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==EXCLUDING || _la==INCLUDING) { + { + { + setState(2923); + _la = _input.LA(1); + if ( !(_la==EXCLUDING || _la==INCLUDING) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2924); + tablelikeoption(); + } + } + setState(2929); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TablelikeoptionContext extends ParserRuleContext { + public TerminalNode COMMENTS() { return getToken(PostgreSqlParser.COMMENTS, 0); } + public TerminalNode CONSTRAINTS() { return getToken(PostgreSqlParser.CONSTRAINTS, 0); } + public TerminalNode DEFAULTS() { return getToken(PostgreSqlParser.DEFAULTS, 0); } + public TerminalNode IDENTITY_P() { return getToken(PostgreSqlParser.IDENTITY_P, 0); } + public TerminalNode GENERATED() { return getToken(PostgreSqlParser.GENERATED, 0); } + public TerminalNode INDEXES() { return getToken(PostgreSqlParser.INDEXES, 0); } + public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } + public TerminalNode STORAGE() { return getToken(PostgreSqlParser.STORAGE, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TablelikeoptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tablelikeoption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTablelikeoption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTablelikeoption(this); + } + } + + public final TablelikeoptionContext tablelikeoption() throws RecognitionException { + TablelikeoptionContext _localctx = new TablelikeoptionContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_tablelikeoption); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2930); + _la = _input.LA(1); + if ( !(_la==ALL || ((((_la - 162)) & ~0x3f) == 0 && ((1L << (_la - 162)) & 576460752303947809L) != 0) || _la==INDEXES || _la==STATISTICS || _la==STORAGE || _la==GENERATED) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TableconstraintContext extends ParserRuleContext { + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public ConstraintelemContext constraintelem() { + return getRuleContext(ConstraintelemContext.class,0); + } + public TableconstraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tableconstraint; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTableconstraint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTableconstraint(this); + } + } + + public final TableconstraintContext tableconstraint() throws RecognitionException { + TableconstraintContext _localctx = new TableconstraintContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_tableconstraint); + try { + setState(2937); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CONSTRAINT: + enterOuterAlt(_localctx, 1); + { + setState(2932); + match(CONSTRAINT); + setState(2933); + name(); + setState(2934); + constraintelem(); + } + break; + case CHECK: + case FOREIGN: + case PRIMARY: + case UNIQUE: + case EXCLUDE: + enterOuterAlt(_localctx, 2); + { + setState(2936); + constraintelem(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstraintelemContext extends ParserRuleContext { + public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ConstraintattributespecContext constraintattributespec() { + return getRuleContext(ConstraintattributespecContext.class,0); + } + public TerminalNode UNIQUE() { return getToken(PostgreSqlParser.UNIQUE, 0); } + public ColumnlistContext columnlist() { + return getRuleContext(ColumnlistContext.class,0); + } + public Opt_c_includeContext opt_c_include() { + return getRuleContext(Opt_c_includeContext.class,0); + } + public Opt_definitionContext opt_definition() { + return getRuleContext(Opt_definitionContext.class,0); + } + public OptconstablespaceContext optconstablespace() { + return getRuleContext(OptconstablespaceContext.class,0); + } + public ExistingindexContext existingindex() { + return getRuleContext(ExistingindexContext.class,0); + } + public TerminalNode PRIMARY() { return getToken(PostgreSqlParser.PRIMARY, 0); } + public TerminalNode KEY() { return getToken(PostgreSqlParser.KEY, 0); } + public TerminalNode EXCLUDE() { return getToken(PostgreSqlParser.EXCLUDE, 0); } + public Access_method_clauseContext access_method_clause() { + return getRuleContext(Access_method_clauseContext.class,0); + } + public ExclusionconstraintlistContext exclusionconstraintlist() { + return getRuleContext(ExclusionconstraintlistContext.class,0); + } + public ExclusionwhereclauseContext exclusionwhereclause() { + return getRuleContext(ExclusionwhereclauseContext.class,0); + } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode REFERENCES() { return getToken(PostgreSqlParser.REFERENCES, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Opt_column_listContext opt_column_list() { + return getRuleContext(Opt_column_listContext.class,0); + } + public Key_matchContext key_match() { + return getRuleContext(Key_matchContext.class,0); + } + public Key_actionsContext key_actions() { + return getRuleContext(Key_actionsContext.class,0); + } + public ConstraintelemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constraintelem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstraintelem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstraintelem(this); + } + } + + public final ConstraintelemContext constraintelem() throws RecognitionException { + ConstraintelemContext _localctx = new ConstraintelemContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_constraintelem); + try { + setState(2997); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CHECK: + enterOuterAlt(_localctx, 1); + { + setState(2939); + match(CHECK); + setState(2940); + match(OPEN_PAREN); + setState(2941); + a_expr(); + setState(2942); + match(CLOSE_PAREN); + setState(2943); + constraintattributespec(); + } + break; + case UNIQUE: + enterOuterAlt(_localctx, 2); + { + setState(2945); + match(UNIQUE); + setState(2957); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + { + setState(2946); + match(OPEN_PAREN); + setState(2947); + columnlist(); + setState(2948); + match(CLOSE_PAREN); + setState(2949); + opt_c_include(); + setState(2950); + opt_definition(); + setState(2951); + optconstablespace(); + setState(2952); + constraintattributespec(); + } + break; + case USING: + { + setState(2954); + existingindex(); + setState(2955); + constraintattributespec(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case PRIMARY: + enterOuterAlt(_localctx, 3); + { + setState(2959); + match(PRIMARY); + setState(2960); + match(KEY); + setState(2972); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + { + setState(2961); + match(OPEN_PAREN); + setState(2962); + columnlist(); + setState(2963); + match(CLOSE_PAREN); + setState(2964); + opt_c_include(); + setState(2965); + opt_definition(); + setState(2966); + optconstablespace(); + setState(2967); + constraintattributespec(); + } + break; + case USING: + { + setState(2969); + existingindex(); + setState(2970); + constraintattributespec(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case EXCLUDE: + enterOuterAlt(_localctx, 4); + { + setState(2974); + match(EXCLUDE); + setState(2975); + access_method_clause(); + setState(2976); + match(OPEN_PAREN); + setState(2977); + exclusionconstraintlist(); + setState(2978); + match(CLOSE_PAREN); + setState(2979); + opt_c_include(); + setState(2980); + opt_definition(); + setState(2981); + optconstablespace(); + setState(2982); + exclusionwhereclause(); + setState(2983); + constraintattributespec(); + } + break; + case FOREIGN: + enterOuterAlt(_localctx, 5); + { + setState(2985); + match(FOREIGN); + setState(2986); + match(KEY); + setState(2987); + match(OPEN_PAREN); + setState(2988); + columnlist(); + setState(2989); + match(CLOSE_PAREN); + setState(2990); + match(REFERENCES); + setState(2991); + qualified_name(); + setState(2992); + opt_column_list(); + setState(2993); + key_match(); + setState(2994); + key_actions(); + setState(2995); + constraintattributespec(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_no_inheritContext extends ParserRuleContext { + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode INHERIT() { return getToken(PostgreSqlParser.INHERIT, 0); } + public Opt_no_inheritContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_no_inherit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_no_inherit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_no_inherit(this); + } + } + + public final Opt_no_inheritContext opt_no_inherit() throws RecognitionException { + Opt_no_inheritContext _localctx = new Opt_no_inheritContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_opt_no_inherit); + try { + setState(3002); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NO: + enterOuterAlt(_localctx, 1); + { + setState(2999); + match(NO); + setState(3000); + match(INHERIT); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CHECK: + case COLLATE: + case CONSTRAINT: + case CREATE: + case DEFAULT: + case DEFERRABLE: + case DO: + case FETCH: + case GRANT: + case INITIALLY: + case INTO: + case NOT: + case NULL_P: + case PRIMARY: + case REFERENCES: + case SELECT: + case TABLE: + case UNIQUE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case GENERATED: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_column_listContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public ColumnlistContext columnlist() { + return getRuleContext(ColumnlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_column_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_column_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_column_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_column_list(this); + } + } + + public final Opt_column_listContext opt_column_list() throws RecognitionException { + Opt_column_listContext _localctx = new Opt_column_listContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_opt_column_list); + try { + setState(3009); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3004); + match(OPEN_PAREN); + setState(3005); + columnlist(); + setState(3006); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColumnlistContext extends ParserRuleContext { + public List columnElem() { + return getRuleContexts(ColumnElemContext.class); + } + public ColumnElemContext columnElem(int i) { + return getRuleContext(ColumnElemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public ColumnlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_columnlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumnlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumnlist(this); + } + } + + public final ColumnlistContext columnlist() throws RecognitionException { + ColumnlistContext _localctx = new ColumnlistContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_columnlist); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3011); + columnElem(); + setState(3016); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3012); + match(COMMA); + setState(3013); + columnElem(); + } + } + setState(3018); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColumnElemContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public ColumnElemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_columnElem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumnElem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumnElem(this); + } + } + + public final ColumnElemContext columnElem() throws RecognitionException { + ColumnElemContext _localctx = new ColumnElemContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_columnElem); + try { + enterOuterAlt(_localctx, 1); + { + setState(3019); + colid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_c_includeContext extends ParserRuleContext { + public TerminalNode INCLUDE() { return getToken(PostgreSqlParser.INCLUDE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public ColumnlistContext columnlist() { + return getRuleContext(ColumnlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_c_includeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_c_include; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_c_include(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_c_include(this); + } + } + + public final Opt_c_includeContext opt_c_include() throws RecognitionException { + Opt_c_includeContext _localctx = new Opt_c_includeContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_opt_c_include); + try { + setState(3027); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INCLUDE: + enterOuterAlt(_localctx, 1); + { + setState(3021); + match(INCLUDE); + setState(3022); + match(OPEN_PAREN); + setState(3023); + columnlist(); + setState(3024); + match(CLOSE_PAREN); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DEFERRABLE: + case DO: + case FETCH: + case GRANT: + case INITIALLY: + case INTO: + case NOT: + case SELECT: + case TABLE: + case USING: + case WHERE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NO: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Key_matchContext extends ParserRuleContext { + public TerminalNode MATCH() { return getToken(PostgreSqlParser.MATCH, 0); } + public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } + public TerminalNode PARTIAL() { return getToken(PostgreSqlParser.PARTIAL, 0); } + public TerminalNode SIMPLE() { return getToken(PostgreSqlParser.SIMPLE, 0); } + public Key_matchContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_key_match; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterKey_match(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitKey_match(this); + } + } + + public final Key_matchContext key_match() throws RecognitionException { + Key_matchContext _localctx = new Key_matchContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_key_match); + int _la; + try { + setState(3032); + _errHandler.sync(this); + switch (_input.LA(1)) { + case MATCH: + enterOuterAlt(_localctx, 1); + { + setState(3029); + match(MATCH); + setState(3030); + _la = _input.LA(1); + if ( !(_la==FULL || _la==PARTIAL || _la==SIMPLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CHECK: + case COLLATE: + case CONSTRAINT: + case CREATE: + case DEFAULT: + case DEFERRABLE: + case DO: + case FETCH: + case GRANT: + case INITIALLY: + case INTO: + case NOT: + case NULL_P: + case ON: + case PRIMARY: + case REFERENCES: + case SELECT: + case TABLE: + case UNIQUE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NO: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case GENERATED: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExclusionconstraintlistContext extends ParserRuleContext { + public List exclusionconstraintelem() { + return getRuleContexts(ExclusionconstraintelemContext.class); + } + public ExclusionconstraintelemContext exclusionconstraintelem(int i) { + return getRuleContext(ExclusionconstraintelemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public ExclusionconstraintlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exclusionconstraintlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExclusionconstraintlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExclusionconstraintlist(this); + } + } + + public final ExclusionconstraintlistContext exclusionconstraintlist() throws RecognitionException { + ExclusionconstraintlistContext _localctx = new ExclusionconstraintlistContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_exclusionconstraintlist); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3034); + exclusionconstraintelem(); + setState(3039); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3035); + match(COMMA); + setState(3036); + exclusionconstraintelem(); + } + } + setState(3041); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExclusionconstraintelemContext extends ParserRuleContext { + public Index_elemContext index_elem() { + return getRuleContext(Index_elemContext.class,0); + } + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public Any_operatorContext any_operator() { + return getRuleContext(Any_operatorContext.class,0); + } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ExclusionconstraintelemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exclusionconstraintelem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExclusionconstraintelem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExclusionconstraintelem(this); + } + } + + public final ExclusionconstraintelemContext exclusionconstraintelem() throws RecognitionException { + ExclusionconstraintelemContext _localctx = new ExclusionconstraintelemContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_exclusionconstraintelem); + try { + enterOuterAlt(_localctx, 1); + { + setState(3042); + index_elem(); + setState(3043); + match(WITH); + setState(3050); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) { + case 1: + { + setState(3044); + any_operator(); + } + break; + case 2: + { + setState(3045); + match(OPERATOR); + setState(3046); + match(OPEN_PAREN); + setState(3047); + any_operator(); + setState(3048); + match(CLOSE_PAREN); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExclusionwhereclauseContext extends ParserRuleContext { + public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ExclusionwhereclauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exclusionwhereclause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExclusionwhereclause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExclusionwhereclause(this); + } + } + + public final ExclusionwhereclauseContext exclusionwhereclause() throws RecognitionException { + ExclusionwhereclauseContext _localctx = new ExclusionwhereclauseContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_exclusionwhereclause); + try { + setState(3058); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WHERE: + enterOuterAlt(_localctx, 1); + { + setState(3052); + match(WHERE); + setState(3053); + match(OPEN_PAREN); + setState(3054); + a_expr(); + setState(3055); + match(CLOSE_PAREN); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DEFERRABLE: + case DO: + case FETCH: + case GRANT: + case INITIALLY: + case INTO: + case NOT: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NO: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Key_actionsContext extends ParserRuleContext { + public Key_updateContext key_update() { + return getRuleContext(Key_updateContext.class,0); + } + public Key_deleteContext key_delete() { + return getRuleContext(Key_deleteContext.class,0); + } + public Key_actionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_key_actions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterKey_actions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitKey_actions(this); + } + } + + public final Key_actionsContext key_actions() throws RecognitionException { + Key_actionsContext _localctx = new Key_actionsContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_key_actions); + try { + setState(3069); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3060); + key_update(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3061); + key_delete(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3062); + key_update(); + setState(3063); + key_delete(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3065); + key_delete(); + setState(3066); + key_update(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Key_updateContext extends ParserRuleContext { + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public Key_actionContext key_action() { + return getRuleContext(Key_actionContext.class,0); + } + public Key_updateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_key_update; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterKey_update(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitKey_update(this); + } + } + + public final Key_updateContext key_update() throws RecognitionException { + Key_updateContext _localctx = new Key_updateContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_key_update); + try { + enterOuterAlt(_localctx, 1); + { + setState(3071); + match(ON); + setState(3072); + match(UPDATE); + setState(3073); + key_action(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Key_deleteContext extends ParserRuleContext { + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public TerminalNode DELETE_P() { return getToken(PostgreSqlParser.DELETE_P, 0); } + public Key_actionContext key_action() { + return getRuleContext(Key_actionContext.class,0); + } + public Key_deleteContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_key_delete; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterKey_delete(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitKey_delete(this); + } + } + + public final Key_deleteContext key_delete() throws RecognitionException { + Key_deleteContext _localctx = new Key_deleteContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_key_delete); + try { + enterOuterAlt(_localctx, 1); + { + setState(3075); + match(ON); + setState(3076); + match(DELETE_P); + setState(3077); + key_action(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Key_actionContext extends ParserRuleContext { + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode ACTION() { return getToken(PostgreSqlParser.ACTION, 0); } + public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } + public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public Key_actionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_key_action; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterKey_action(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitKey_action(this); + } + } + + public final Key_actionContext key_action() throws RecognitionException { + Key_actionContext _localctx = new Key_actionContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_key_action); + int _la; + try { + setState(3085); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NO: + enterOuterAlt(_localctx, 1); + { + setState(3079); + match(NO); + setState(3080); + match(ACTION); + } + break; + case RESTRICT: + enterOuterAlt(_localctx, 2); + { + setState(3081); + match(RESTRICT); + } + break; + case CASCADE: + enterOuterAlt(_localctx, 3); + { + setState(3082); + match(CASCADE); + } + break; + case SET: + enterOuterAlt(_localctx, 4); + { + setState(3083); + match(SET); + setState(3084); + _la = _input.LA(1); + if ( !(_la==DEFAULT || _la==NULL_P) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptinheritContext extends ParserRuleContext { + public TerminalNode INHERITS() { return getToken(PostgreSqlParser.INHERITS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Qualified_name_listContext qualified_name_list() { + return getRuleContext(Qualified_name_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public OptinheritContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optinherit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptinherit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptinherit(this); + } + } + + public final OptinheritContext optinherit() throws RecognitionException { + OptinheritContext _localctx = new OptinheritContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_optinherit); + try { + setState(3093); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INHERITS: + enterOuterAlt(_localctx, 1); + { + setState(3087); + match(INHERITS); + setState(3088); + match(OPEN_PAREN); + setState(3089); + qualified_name_list(); + setState(3090); + match(CLOSE_PAREN); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case ON: + case SELECT: + case TABLE: + case USING: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PARTITION: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SERVER: + case SET: + case SHOW: + case START: + case TABLESPACE: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case WITHOUT: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptpartitionspecContext extends ParserRuleContext { + public PartitionspecContext partitionspec() { + return getRuleContext(PartitionspecContext.class,0); + } + public OptpartitionspecContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optpartitionspec; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptpartitionspec(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptpartitionspec(this); + } + } + + public final OptpartitionspecContext optpartitionspec() throws RecognitionException { + OptpartitionspecContext _localctx = new OptpartitionspecContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_optpartitionspec); + try { + setState(3097); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PARTITION: + enterOuterAlt(_localctx, 1); + { + setState(3095); + partitionspec(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case ON: + case SELECT: + case TABLE: + case USING: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TABLESPACE: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case WITHOUT: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PartitionspecContext extends ParserRuleContext { + public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Part_paramsContext part_params() { + return getRuleContext(Part_paramsContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public PartitionspecContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_partitionspec; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPartitionspec(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPartitionspec(this); + } + } + + public final PartitionspecContext partitionspec() throws RecognitionException { + PartitionspecContext _localctx = new PartitionspecContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_partitionspec); + try { + enterOuterAlt(_localctx, 1); + { + setState(3099); + match(PARTITION); + setState(3100); + match(BY); + setState(3101); + colid(); + setState(3102); + match(OPEN_PAREN); + setState(3103); + part_params(); + setState(3104); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Part_paramsContext extends ParserRuleContext { + public List part_elem() { + return getRuleContexts(Part_elemContext.class); + } + public Part_elemContext part_elem(int i) { + return getRuleContext(Part_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Part_paramsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_part_params; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPart_params(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPart_params(this); + } + } + + public final Part_paramsContext part_params() throws RecognitionException { + Part_paramsContext _localctx = new Part_paramsContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_part_params); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3106); + part_elem(); + setState(3111); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3107); + match(COMMA); + setState(3108); + part_elem(); + } + } + setState(3113); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Part_elemContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Opt_collateContext opt_collate() { + return getRuleContext(Opt_collateContext.class,0); + } + public Opt_classContext opt_class() { + return getRuleContext(Opt_classContext.class,0); + } + public Func_expr_windowlessContext func_expr_windowless() { + return getRuleContext(Func_expr_windowlessContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Part_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_part_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPart_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPart_elem(this); + } + } + + public final Part_elemContext part_elem() throws RecognitionException { + Part_elemContext _localctx = new Part_elemContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_part_elem); + try { + setState(3128); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3114); + colid(); + setState(3115); + opt_collate(); + setState(3116); + opt_class(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3118); + func_expr_windowless(); + setState(3119); + opt_collate(); + setState(3120); + opt_class(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3122); + match(OPEN_PAREN); + setState(3123); + a_expr(); + setState(3124); + match(CLOSE_PAREN); + setState(3125); + opt_collate(); + setState(3126); + opt_class(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Table_access_method_clauseContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Table_access_method_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_table_access_method_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTable_access_method_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTable_access_method_clause(this); + } + } + + public final Table_access_method_clauseContext table_access_method_clause() throws RecognitionException { + Table_access_method_clauseContext _localctx = new Table_access_method_clauseContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_table_access_method_clause); + try { + setState(3133); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(3130); + match(USING); + setState(3131); + name(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case AS: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case ON: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TABLESPACE: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case WITHOUT: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptwithContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public ReloptionsContext reloptions() { + return getRuleContext(ReloptionsContext.class,0); + } + public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } + public TerminalNode OIDS() { return getToken(PostgreSqlParser.OIDS, 0); } + public OptwithContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optwith; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptwith(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptwith(this); + } + } + + public final OptwithContext optwith() throws RecognitionException { + OptwithContext _localctx = new OptwithContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_optwith); + try { + setState(3140); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3135); + match(WITH); + setState(3136); + reloptions(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3137); + match(WITHOUT); + setState(3138); + match(OIDS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OncommitoptionContext extends ParserRuleContext { + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public TerminalNode COMMIT() { return getToken(PostgreSqlParser.COMMIT, 0); } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode DELETE_P() { return getToken(PostgreSqlParser.DELETE_P, 0); } + public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } + public TerminalNode PRESERVE() { return getToken(PostgreSqlParser.PRESERVE, 0); } + public OncommitoptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_oncommitoption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOncommitoption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOncommitoption(this); + } + } + + public final OncommitoptionContext oncommitoption() throws RecognitionException { + OncommitoptionContext _localctx = new OncommitoptionContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_oncommitoption); + try { + setState(3152); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ON: + enterOuterAlt(_localctx, 1); + { + setState(3142); + match(ON); + setState(3143); + match(COMMIT); + setState(3149); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DROP: + { + setState(3144); + match(DROP); + } + break; + case DELETE_P: + { + setState(3145); + match(DELETE_P); + setState(3146); + match(ROWS); + } + break; + case PRESERVE: + { + setState(3147); + match(PRESERVE); + setState(3148); + match(ROWS); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case AS: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TABLESPACE: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OpttablespaceContext extends ParserRuleContext { + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public OpttablespaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opttablespace; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpttablespace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpttablespace(this); + } + } + + public final OpttablespaceContext opttablespace() throws RecognitionException { + OpttablespaceContext _localctx = new OpttablespaceContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_opttablespace); + try { + setState(3157); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TABLESPACE: + enterOuterAlt(_localctx, 1); + { + setState(3154); + match(TABLESPACE); + setState(3155); + name(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case AS: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WHERE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptconstablespaceContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public OptconstablespaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optconstablespace; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptconstablespace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptconstablespace(this); + } + } + + public final OptconstablespaceContext optconstablespace() throws RecognitionException { + OptconstablespaceContext _localctx = new OptconstablespaceContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_optconstablespace); + try { + setState(3164); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(3159); + match(USING); + setState(3160); + match(INDEX); + setState(3161); + match(TABLESPACE); + setState(3162); + name(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CHECK: + case COLLATE: + case CONSTRAINT: + case CREATE: + case DEFAULT: + case DEFERRABLE: + case DO: + case FETCH: + case GRANT: + case INITIALLY: + case INTO: + case NOT: + case NULL_P: + case PRIMARY: + case REFERENCES: + case SELECT: + case TABLE: + case UNIQUE: + case WHERE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NO: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case GENERATED: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExistingindexContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public ExistingindexContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_existingindex; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExistingindex(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExistingindex(this); + } + } + + public final ExistingindexContext existingindex() throws RecognitionException { + ExistingindexContext _localctx = new ExistingindexContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_existingindex); + try { + enterOuterAlt(_localctx, 1); + { + setState(3166); + match(USING); + setState(3167); + match(INDEX); + setState(3168); + name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatestatsstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Opt_name_listContext opt_name_list() { + return getRuleContext(Opt_name_listContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public From_listContext from_list() { + return getRuleContext(From_listContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreatestatsstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createstatsstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatestatsstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatestatsstmt(this); + } + } + + public final CreatestatsstmtContext createstatsstmt() throws RecognitionException { + CreatestatsstmtContext _localctx = new CreatestatsstmtContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_createstatsstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3170); + match(CREATE); + setState(3171); + match(STATISTICS); + setState(3175); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { + case 1: + { + setState(3172); + match(IF_P); + setState(3173); + match(NOT); + setState(3174); + match(EXISTS); + } + break; + } + setState(3177); + any_name(); + setState(3178); + opt_name_list(); + setState(3179); + match(ON); + setState(3180); + expr_list(); + setState(3181); + match(FROM); + setState(3182); + from_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterstatsstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public List STATISTICS() { return getTokens(PostgreSqlParser.STATISTICS); } + public TerminalNode STATISTICS(int i) { + return getToken(PostgreSqlParser.STATISTICS, i); + } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public SignediconstContext signediconst() { + return getRuleContext(SignediconstContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public AlterstatsstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterstatsstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterstatsstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterstatsstmt(this); + } + } + + public final AlterstatsstmtContext alterstatsstmt() throws RecognitionException { + AlterstatsstmtContext _localctx = new AlterstatsstmtContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_alterstatsstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3184); + match(ALTER); + setState(3185); + match(STATISTICS); + setState(3188); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) { + case 1: + { + setState(3186); + match(IF_P); + setState(3187); + match(EXISTS); + } + break; + } + setState(3190); + any_name(); + setState(3191); + match(SET); + setState(3192); + match(STATISTICS); + setState(3193); + signediconst(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateasstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public OpttempContext opttemp() { + return getRuleContext(OpttempContext.class,0); + } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Create_as_targetContext create_as_target() { + return getRuleContext(Create_as_targetContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public Opt_with_dataContext opt_with_data() { + return getRuleContext(Opt_with_dataContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreateasstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createasstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateasstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateasstmt(this); + } + } + + public final CreateasstmtContext createasstmt() throws RecognitionException { + CreateasstmtContext _localctx = new CreateasstmtContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_createasstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3195); + match(CREATE); + setState(3196); + opttemp(); + setState(3197); + match(TABLE); + setState(3201); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { + case 1: + { + setState(3198); + match(IF_P); + setState(3199); + match(NOT); + setState(3200); + match(EXISTS); + } + break; + } + setState(3203); + create_as_target(); + setState(3204); + match(AS); + setState(3205); + selectstmt(); + setState(3206); + opt_with_data(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Create_as_targetContext extends ParserRuleContext { + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Opt_column_listContext opt_column_list() { + return getRuleContext(Opt_column_listContext.class,0); + } + public Table_access_method_clauseContext table_access_method_clause() { + return getRuleContext(Table_access_method_clauseContext.class,0); + } + public OptwithContext optwith() { + return getRuleContext(OptwithContext.class,0); + } + public OncommitoptionContext oncommitoption() { + return getRuleContext(OncommitoptionContext.class,0); + } + public OpttablespaceContext opttablespace() { + return getRuleContext(OpttablespaceContext.class,0); + } + public Create_as_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_create_as_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_as_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_as_target(this); + } + } + + public final Create_as_targetContext create_as_target() throws RecognitionException { + Create_as_targetContext _localctx = new Create_as_targetContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_create_as_target); + try { + enterOuterAlt(_localctx, 1); + { + setState(3208); + qualified_name(); + setState(3209); + opt_column_list(); + setState(3210); + table_access_method_clause(); + setState(3211); + optwith(); + setState(3212); + oncommitoption(); + setState(3213); + opttablespace(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_with_dataContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public Opt_with_dataContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_with_data; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_with_data(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_with_data(this); + } + } + + public final Opt_with_dataContext opt_with_data() throws RecognitionException { + Opt_with_dataContext _localctx = new Opt_with_dataContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_opt_with_data); + try { + setState(3222); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3215); + match(WITH); + setState(3219); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DATA_P: + { + setState(3216); + match(DATA_P); + } + break; + case NO: + { + setState(3217); + match(NO); + setState(3218); + match(DATA_P); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatematviewstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public OptnologContext optnolog() { + return getRuleContext(OptnologContext.class,0); + } + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public Create_mv_targetContext create_mv_target() { + return getRuleContext(Create_mv_targetContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public Opt_with_dataContext opt_with_data() { + return getRuleContext(Opt_with_dataContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreatematviewstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_creatematviewstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatematviewstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatematviewstmt(this); + } + } + + public final CreatematviewstmtContext creatematviewstmt() throws RecognitionException { + CreatematviewstmtContext _localctx = new CreatematviewstmtContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_creatematviewstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3224); + match(CREATE); + setState(3225); + optnolog(); + setState(3226); + match(MATERIALIZED); + setState(3227); + match(VIEW); + setState(3231); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { + case 1: + { + setState(3228); + match(IF_P); + setState(3229); + match(NOT); + setState(3230); + match(EXISTS); + } + break; + } + setState(3233); + create_mv_target(); + setState(3234); + match(AS); + setState(3235); + selectstmt(); + setState(3236); + opt_with_data(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Create_mv_targetContext extends ParserRuleContext { + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Opt_column_listContext opt_column_list() { + return getRuleContext(Opt_column_listContext.class,0); + } + public Table_access_method_clauseContext table_access_method_clause() { + return getRuleContext(Table_access_method_clauseContext.class,0); + } + public Opt_reloptionsContext opt_reloptions() { + return getRuleContext(Opt_reloptionsContext.class,0); + } + public OpttablespaceContext opttablespace() { + return getRuleContext(OpttablespaceContext.class,0); + } + public Create_mv_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_create_mv_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_mv_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_mv_target(this); + } + } + + public final Create_mv_targetContext create_mv_target() throws RecognitionException { + Create_mv_targetContext _localctx = new Create_mv_targetContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_create_mv_target); + try { + enterOuterAlt(_localctx, 1); + { + setState(3238); + qualified_name(); + setState(3239); + opt_column_list(); + setState(3240); + table_access_method_clause(); + setState(3241); + opt_reloptions(); + setState(3242); + opttablespace(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptnologContext extends ParserRuleContext { + public TerminalNode UNLOGGED() { return getToken(PostgreSqlParser.UNLOGGED, 0); } + public OptnologContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optnolog; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptnolog(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptnolog(this); + } + } + + public final OptnologContext optnolog() throws RecognitionException { + OptnologContext _localctx = new OptnologContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_optnolog); + try { + setState(3246); + _errHandler.sync(this); + switch (_input.LA(1)) { + case UNLOGGED: + enterOuterAlt(_localctx, 1); + { + setState(3244); + match(UNLOGGED); + } + break; + case MATERIALIZED: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RefreshmatviewstmtContext extends ParserRuleContext { + public TerminalNode REFRESH() { return getToken(PostgreSqlParser.REFRESH, 0); } + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public Opt_concurrentlyContext opt_concurrently() { + return getRuleContext(Opt_concurrentlyContext.class,0); + } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Opt_with_dataContext opt_with_data() { + return getRuleContext(Opt_with_dataContext.class,0); + } + public RefreshmatviewstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_refreshmatviewstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRefreshmatviewstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRefreshmatviewstmt(this); + } + } + + public final RefreshmatviewstmtContext refreshmatviewstmt() throws RecognitionException { + RefreshmatviewstmtContext _localctx = new RefreshmatviewstmtContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_refreshmatviewstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3248); + match(REFRESH); + setState(3249); + match(MATERIALIZED); + setState(3250); + match(VIEW); + setState(3251); + opt_concurrently(); + setState(3252); + qualified_name(); + setState(3253); + opt_with_data(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateseqstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public OpttempContext opttemp() { + return getRuleContext(OpttempContext.class,0); + } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public OptseqoptlistContext optseqoptlist() { + return getRuleContext(OptseqoptlistContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreateseqstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createseqstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateseqstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateseqstmt(this); + } + } + + public final CreateseqstmtContext createseqstmt() throws RecognitionException { + CreateseqstmtContext _localctx = new CreateseqstmtContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_createseqstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3255); + match(CREATE); + setState(3256); + opttemp(); + setState(3257); + match(SEQUENCE); + setState(3261); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { + case 1: + { + setState(3258); + match(IF_P); + setState(3259); + match(NOT); + setState(3260); + match(EXISTS); + } + break; + } + setState(3263); + qualified_name(); + setState(3264); + optseqoptlist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterseqstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public SeqoptlistContext seqoptlist() { + return getRuleContext(SeqoptlistContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public AlterseqstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterseqstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterseqstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterseqstmt(this); + } + } + + public final AlterseqstmtContext alterseqstmt() throws RecognitionException { + AlterseqstmtContext _localctx = new AlterseqstmtContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_alterseqstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3266); + match(ALTER); + setState(3267); + match(SEQUENCE); + setState(3270); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { + case 1: + { + setState(3268); + match(IF_P); + setState(3269); + match(EXISTS); + } + break; + } + setState(3272); + qualified_name(); + setState(3273); + seqoptlist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptseqoptlistContext extends ParserRuleContext { + public SeqoptlistContext seqoptlist() { + return getRuleContext(SeqoptlistContext.class,0); + } + public OptseqoptlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optseqoptlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptseqoptlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptseqoptlist(this); + } + } + + public final OptseqoptlistContext optseqoptlist() throws RecognitionException { + OptseqoptlistContext _localctx = new OptseqoptlistContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_optseqoptlist); + try { + setState(3277); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3275); + seqoptlist(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptparenthesizedseqoptlistContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public SeqoptlistContext seqoptlist() { + return getRuleContext(SeqoptlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public OptparenthesizedseqoptlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optparenthesizedseqoptlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptparenthesizedseqoptlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptparenthesizedseqoptlist(this); + } + } + + public final OptparenthesizedseqoptlistContext optparenthesizedseqoptlist() throws RecognitionException { + OptparenthesizedseqoptlistContext _localctx = new OptparenthesizedseqoptlistContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_optparenthesizedseqoptlist); + try { + setState(3284); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3279); + match(OPEN_PAREN); + setState(3280); + seqoptlist(); + setState(3281); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SeqoptlistContext extends ParserRuleContext { + public List seqoptelem() { + return getRuleContexts(SeqoptelemContext.class); + } + public SeqoptelemContext seqoptelem(int i) { + return getRuleContext(SeqoptelemContext.class,i); + } + public SeqoptlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_seqoptlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSeqoptlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSeqoptlist(this); + } + } + + public final SeqoptlistContext seqoptlist() throws RecognitionException { + SeqoptlistContext _localctx = new SeqoptlistContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_seqoptlist); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3287); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(3286); + seqoptelem(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3289); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,133,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SeqoptelemContext extends ParserRuleContext { + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public SimpletypenameContext simpletypename() { + return getRuleContext(SimpletypenameContext.class,0); + } + public TerminalNode CACHE() { return getToken(PostgreSqlParser.CACHE, 0); } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public TerminalNode CYCLE() { return getToken(PostgreSqlParser.CYCLE, 0); } + public TerminalNode INCREMENT() { return getToken(PostgreSqlParser.INCREMENT, 0); } + public Opt_byContext opt_by() { + return getRuleContext(Opt_byContext.class,0); + } + public TerminalNode MAXVALUE() { return getToken(PostgreSqlParser.MAXVALUE, 0); } + public TerminalNode MINVALUE() { return getToken(PostgreSqlParser.MINVALUE, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public TerminalNode NAME_P() { return getToken(PostgreSqlParser.NAME_P, 0); } + public TerminalNode START() { return getToken(PostgreSqlParser.START, 0); } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public TerminalNode RESTART() { return getToken(PostgreSqlParser.RESTART, 0); } + public SeqoptelemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_seqoptelem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSeqoptelem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSeqoptelem(this); + } + } + + public final SeqoptelemContext seqoptelem() throws RecognitionException { + SeqoptelemContext _localctx = new SeqoptelemContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_seqoptelem); + int _la; + try { + setState(3321); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AS: + enterOuterAlt(_localctx, 1); + { + setState(3291); + match(AS); + setState(3292); + simpletypename(); + } + break; + case CACHE: + enterOuterAlt(_localctx, 2); + { + setState(3293); + match(CACHE); + setState(3294); + numericonly(); + } + break; + case CYCLE: + enterOuterAlt(_localctx, 3); + { + setState(3295); + match(CYCLE); + } + break; + case INCREMENT: + enterOuterAlt(_localctx, 4); + { + setState(3296); + match(INCREMENT); + setState(3297); + opt_by(); + setState(3298); + numericonly(); + } + break; + case MAXVALUE: + enterOuterAlt(_localctx, 5); + { + setState(3300); + match(MAXVALUE); + setState(3301); + numericonly(); + } + break; + case MINVALUE: + enterOuterAlt(_localctx, 6); + { + setState(3302); + match(MINVALUE); + setState(3303); + numericonly(); + } + break; + case NO: + enterOuterAlt(_localctx, 7); + { + setState(3304); + match(NO); + setState(3305); + _la = _input.LA(1); + if ( !(_la==CYCLE || _la==MAXVALUE || _la==MINVALUE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case OWNED: + enterOuterAlt(_localctx, 8); + { + setState(3306); + match(OWNED); + setState(3307); + match(BY); + setState(3308); + any_name(); + } + break; + case SEQUENCE: + enterOuterAlt(_localctx, 9); + { + setState(3309); + match(SEQUENCE); + setState(3310); + match(NAME_P); + setState(3311); + any_name(); + } + break; + case START: + enterOuterAlt(_localctx, 10); + { + setState(3312); + match(START); + setState(3313); + opt_with(); + setState(3314); + numericonly(); + } + break; + case RESTART: + enterOuterAlt(_localctx, 11); + { + setState(3316); + match(RESTART); + setState(3317); + opt_with(); + setState(3319); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PLUS || _la==MINUS || _la==Integral || _la==Numeric) { + { + setState(3318); + numericonly(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_byContext extends ParserRuleContext { + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Opt_byContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_by; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_by(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_by(this); + } + } + + public final Opt_byContext opt_by() throws RecognitionException { + Opt_byContext _localctx = new Opt_byContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_opt_by); + try { + setState(3325); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BY: + enterOuterAlt(_localctx, 1); + { + setState(3323); + match(BY); + } + break; + case PLUS: + case MINUS: + case Integral: + case Numeric: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NumericonlyContext extends ParserRuleContext { + public FconstContext fconst() { + return getRuleContext(FconstContext.class,0); + } + public TerminalNode PLUS() { return getToken(PostgreSqlParser.PLUS, 0); } + public TerminalNode MINUS() { return getToken(PostgreSqlParser.MINUS, 0); } + public SignediconstContext signediconst() { + return getRuleContext(SignediconstContext.class,0); + } + public NumericonlyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numericonly; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNumericonly(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNumericonly(this); + } + } + + public final NumericonlyContext numericonly() throws RecognitionException { + NumericonlyContext _localctx = new NumericonlyContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_numericonly); + try { + setState(3333); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3327); + fconst(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3328); + match(PLUS); + setState(3329); + fconst(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3330); + match(MINUS); + setState(3331); + fconst(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3332); + signediconst(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Numericonly_listContext extends ParserRuleContext { + public List numericonly() { + return getRuleContexts(NumericonlyContext.class); + } + public NumericonlyContext numericonly(int i) { + return getRuleContext(NumericonlyContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Numericonly_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numericonly_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNumericonly_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNumericonly_list(this); + } + } + + public final Numericonly_listContext numericonly_list() throws RecognitionException { + Numericonly_listContext _localctx = new Numericonly_listContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_numericonly_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3335); + numericonly(); + setState(3340); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3336); + match(COMMA); + setState(3337); + numericonly(); + } + } + setState(3342); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateplangstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public Opt_or_replaceContext opt_or_replace() { + return getRuleContext(Opt_or_replaceContext.class,0); + } + public Opt_trustedContext opt_trusted() { + return getRuleContext(Opt_trustedContext.class,0); + } + public Opt_proceduralContext opt_procedural() { + return getRuleContext(Opt_proceduralContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode HANDLER() { return getToken(PostgreSqlParser.HANDLER, 0); } + public Handler_nameContext handler_name() { + return getRuleContext(Handler_nameContext.class,0); + } + public Opt_inline_handlerContext opt_inline_handler() { + return getRuleContext(Opt_inline_handlerContext.class,0); + } + public Opt_validatorContext opt_validator() { + return getRuleContext(Opt_validatorContext.class,0); + } + public CreateplangstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createplangstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateplangstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateplangstmt(this); + } + } + + public final CreateplangstmtContext createplangstmt() throws RecognitionException { + CreateplangstmtContext _localctx = new CreateplangstmtContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_createplangstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3343); + match(CREATE); + setState(3344); + opt_or_replace(); + setState(3345); + opt_trusted(); + setState(3346); + opt_procedural(); + setState(3347); + match(LANGUAGE); + setState(3348); + name(); + setState(3354); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==HANDLER) { + { + setState(3349); + match(HANDLER); + setState(3350); + handler_name(); + setState(3351); + opt_inline_handler(); + setState(3352); + opt_validator(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_trustedContext extends ParserRuleContext { + public TerminalNode TRUSTED() { return getToken(PostgreSqlParser.TRUSTED, 0); } + public Opt_trustedContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_trusted; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_trusted(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_trusted(this); + } + } + + public final Opt_trustedContext opt_trusted() throws RecognitionException { + Opt_trustedContext _localctx = new Opt_trustedContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_opt_trusted); + try { + setState(3358); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TRUSTED: + enterOuterAlt(_localctx, 1); + { + setState(3356); + match(TRUSTED); + } + break; + case LANGUAGE: + case PROCEDURAL: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Handler_nameContext extends ParserRuleContext { + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public AttrsContext attrs() { + return getRuleContext(AttrsContext.class,0); + } + public Handler_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handler_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterHandler_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitHandler_name(this); + } + } + + public final Handler_nameContext handler_name() throws RecognitionException { + Handler_nameContext _localctx = new Handler_nameContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_handler_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3360); + name(); + setState(3362); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DOT) { + { + setState(3361); + attrs(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_inline_handlerContext extends ParserRuleContext { + public TerminalNode INLINE_P() { return getToken(PostgreSqlParser.INLINE_P, 0); } + public Handler_nameContext handler_name() { + return getRuleContext(Handler_nameContext.class,0); + } + public Opt_inline_handlerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_inline_handler; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_inline_handler(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_inline_handler(this); + } + } + + public final Opt_inline_handlerContext opt_inline_handler() throws RecognitionException { + Opt_inline_handlerContext _localctx = new Opt_inline_handlerContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_opt_inline_handler); + try { + setState(3367); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INLINE_P: + enterOuterAlt(_localctx, 1); + { + setState(3364); + match(INLINE_P); + setState(3365); + handler_name(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NO: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALIDATOR: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Validator_clauseContext extends ParserRuleContext { + public TerminalNode VALIDATOR() { return getToken(PostgreSqlParser.VALIDATOR, 0); } + public Handler_nameContext handler_name() { + return getRuleContext(Handler_nameContext.class,0); + } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public Validator_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_validator_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterValidator_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitValidator_clause(this); + } + } + + public final Validator_clauseContext validator_clause() throws RecognitionException { + Validator_clauseContext _localctx = new Validator_clauseContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_validator_clause); + try { + setState(3373); + _errHandler.sync(this); + switch (_input.LA(1)) { + case VALIDATOR: + enterOuterAlt(_localctx, 1); + { + setState(3369); + match(VALIDATOR); + setState(3370); + handler_name(); + } + break; + case NO: + enterOuterAlt(_localctx, 2); + { + setState(3371); + match(NO); + setState(3372); + match(VALIDATOR); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_validatorContext extends ParserRuleContext { + public Validator_clauseContext validator_clause() { + return getRuleContext(Validator_clauseContext.class,0); + } + public Opt_validatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_validator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_validator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_validator(this); + } + } + + public final Opt_validatorContext opt_validator() throws RecognitionException { + Opt_validatorContext _localctx = new Opt_validatorContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_opt_validator); + try { + setState(3377); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NO: + case VALIDATOR: + enterOuterAlt(_localctx, 1); + { + setState(3375); + validator_clause(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_proceduralContext extends ParserRuleContext { + public TerminalNode PROCEDURAL() { return getToken(PostgreSqlParser.PROCEDURAL, 0); } + public Opt_proceduralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_procedural; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_procedural(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_procedural(this); + } + } + + public final Opt_proceduralContext opt_procedural() throws RecognitionException { + Opt_proceduralContext _localctx = new Opt_proceduralContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_opt_procedural); + try { + setState(3381); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PROCEDURAL: + enterOuterAlt(_localctx, 1); + { + setState(3379); + match(PROCEDURAL); + } + break; + case LANGUAGE: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatetablespacestmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public OpttablespaceownerContext opttablespaceowner() { + return getRuleContext(OpttablespaceownerContext.class,0); + } + public TerminalNode LOCATION() { return getToken(PostgreSqlParser.LOCATION, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Opt_reloptionsContext opt_reloptions() { + return getRuleContext(Opt_reloptionsContext.class,0); + } + public CreatetablespacestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createtablespacestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatetablespacestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatetablespacestmt(this); + } + } + + public final CreatetablespacestmtContext createtablespacestmt() throws RecognitionException { + CreatetablespacestmtContext _localctx = new CreatetablespacestmtContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_createtablespacestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3383); + match(CREATE); + setState(3384); + match(TABLESPACE); + setState(3385); + name(); + setState(3386); + opttablespaceowner(); + setState(3387); + match(LOCATION); + setState(3388); + sconst(); + setState(3389); + opt_reloptions(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OpttablespaceownerContext extends ParserRuleContext { + public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public OpttablespaceownerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opttablespaceowner; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpttablespaceowner(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpttablespaceowner(this); + } + } + + public final OpttablespaceownerContext opttablespaceowner() throws RecognitionException { + OpttablespaceownerContext _localctx = new OpttablespaceownerContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_opttablespaceowner); + try { + setState(3394); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OWNER: + enterOuterAlt(_localctx, 1); + { + setState(3391); + match(OWNER); + setState(3392); + rolespec(); + } + break; + case LOCATION: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DroptablespacestmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public DroptablespacestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_droptablespacestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDroptablespacestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDroptablespacestmt(this); + } + } + + public final DroptablespacestmtContext droptablespacestmt() throws RecognitionException { + DroptablespacestmtContext _localctx = new DroptablespacestmtContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_droptablespacestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3396); + match(DROP); + setState(3397); + match(TABLESPACE); + setState(3400); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) { + case 1: + { + setState(3398); + match(IF_P); + setState(3399); + match(EXISTS); + } + break; + } + setState(3402); + name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateextensionstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public Create_extension_opt_listContext create_extension_opt_list() { + return getRuleContext(Create_extension_opt_listContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreateextensionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createextensionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateextensionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateextensionstmt(this); + } + } + + public final CreateextensionstmtContext createextensionstmt() throws RecognitionException { + CreateextensionstmtContext _localctx = new CreateextensionstmtContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_createextensionstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3404); + match(CREATE); + setState(3405); + match(EXTENSION); + setState(3409); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { + case 1: + { + setState(3406); + match(IF_P); + setState(3407); + match(NOT); + setState(3408); + match(EXISTS); + } + break; + } + setState(3411); + name(); + setState(3412); + opt_with(); + setState(3413); + create_extension_opt_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Create_extension_opt_listContext extends ParserRuleContext { + public List create_extension_opt_item() { + return getRuleContexts(Create_extension_opt_itemContext.class); + } + public Create_extension_opt_itemContext create_extension_opt_item(int i) { + return getRuleContext(Create_extension_opt_itemContext.class,i); + } + public Create_extension_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_create_extension_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_extension_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_extension_opt_list(this); + } + } + + public final Create_extension_opt_listContext create_extension_opt_list() throws RecognitionException { + Create_extension_opt_listContext _localctx = new Create_extension_opt_listContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_create_extension_opt_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3418); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FROM || _la==CASCADE || _la==SCHEMA || _la==VERSION_P) { + { + { + setState(3415); + create_extension_opt_item(); + } + } + setState(3420); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Create_extension_opt_itemContext extends ParserRuleContext { + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode VERSION_P() { return getToken(PostgreSqlParser.VERSION_P, 0); } + public Nonreservedword_or_sconstContext nonreservedword_or_sconst() { + return getRuleContext(Nonreservedword_or_sconstContext.class,0); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } + public Create_extension_opt_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_create_extension_opt_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_extension_opt_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_extension_opt_item(this); + } + } + + public final Create_extension_opt_itemContext create_extension_opt_item() throws RecognitionException { + Create_extension_opt_itemContext _localctx = new Create_extension_opt_itemContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_create_extension_opt_item); + try { + setState(3428); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SCHEMA: + enterOuterAlt(_localctx, 1); + { + setState(3421); + match(SCHEMA); + setState(3422); + name(); + } + break; + case VERSION_P: + enterOuterAlt(_localctx, 2); + { + setState(3423); + match(VERSION_P); + setState(3424); + nonreservedword_or_sconst(); + } + break; + case FROM: + enterOuterAlt(_localctx, 3); + { + setState(3425); + match(FROM); + setState(3426); + nonreservedword_or_sconst(); + } + break; + case CASCADE: + enterOuterAlt(_localctx, 4); + { + setState(3427); + match(CASCADE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterextensionstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public Alter_extension_opt_listContext alter_extension_opt_list() { + return getRuleContext(Alter_extension_opt_listContext.class,0); + } + public AlterextensionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterextensionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterextensionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterextensionstmt(this); + } + } + + public final AlterextensionstmtContext alterextensionstmt() throws RecognitionException { + AlterextensionstmtContext _localctx = new AlterextensionstmtContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_alterextensionstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3430); + match(ALTER); + setState(3431); + match(EXTENSION); + setState(3432); + name(); + setState(3433); + match(UPDATE); + setState(3434); + alter_extension_opt_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_extension_opt_listContext extends ParserRuleContext { + public List alter_extension_opt_item() { + return getRuleContexts(Alter_extension_opt_itemContext.class); + } + public Alter_extension_opt_itemContext alter_extension_opt_item(int i) { + return getRuleContext(Alter_extension_opt_itemContext.class,i); + } + public Alter_extension_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_extension_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_extension_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_extension_opt_list(this); + } + } + + public final Alter_extension_opt_listContext alter_extension_opt_list() throws RecognitionException { + Alter_extension_opt_listContext _localctx = new Alter_extension_opt_listContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_alter_extension_opt_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3439); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==TO) { + { + { + setState(3436); + alter_extension_opt_item(); + } + } + setState(3441); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_extension_opt_itemContext extends ParserRuleContext { + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Nonreservedword_or_sconstContext nonreservedword_or_sconst() { + return getRuleContext(Nonreservedword_or_sconstContext.class,0); + } + public Alter_extension_opt_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_extension_opt_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_extension_opt_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_extension_opt_item(this); + } + } + + public final Alter_extension_opt_itemContext alter_extension_opt_item() throws RecognitionException { + Alter_extension_opt_itemContext _localctx = new Alter_extension_opt_itemContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_alter_extension_opt_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(3442); + match(TO); + setState(3443); + nonreservedword_or_sconst(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterextensioncontentsstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); + } + public Add_dropContext add_drop() { + return getRuleContext(Add_dropContext.class,0); + } + public Object_type_nameContext object_type_name() { + return getRuleContext(Object_type_nameContext.class,0); + } + public Object_type_any_nameContext object_type_any_name() { + return getRuleContext(Object_type_any_nameContext.class,0); + } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public Aggregate_with_argtypesContext aggregate_with_argtypes() { + return getRuleContext(Aggregate_with_argtypesContext.class,0); + } + public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public Operator_with_argtypesContext operator_with_argtypes() { + return getRuleContext(Operator_with_argtypesContext.class,0); + } + public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public TerminalNode TRANSFORM() { return getToken(PostgreSqlParser.TRANSFORM, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public AlterextensioncontentsstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterextensioncontentsstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterextensioncontentsstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterextensioncontentsstmt(this); + } + } + + public final AlterextensioncontentsstmtContext alterextensioncontentsstmt() throws RecognitionException { + AlterextensioncontentsstmtContext _localctx = new AlterextensioncontentsstmtContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_alterextensioncontentsstmt); + try { + setState(3549); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3445); + match(ALTER); + setState(3446); + match(EXTENSION); + setState(3447); + name(); + setState(3448); + add_drop(); + setState(3449); + object_type_name(); + setState(3450); + name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3452); + match(ALTER); + setState(3453); + match(EXTENSION); + setState(3454); + name(); + setState(3455); + add_drop(); + setState(3456); + object_type_any_name(); + setState(3457); + any_name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3459); + match(ALTER); + setState(3460); + match(EXTENSION); + setState(3461); + name(); + setState(3462); + add_drop(); + setState(3463); + match(AGGREGATE); + setState(3464); + aggregate_with_argtypes(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3466); + match(ALTER); + setState(3467); + match(EXTENSION); + setState(3468); + name(); + setState(3469); + add_drop(); + setState(3470); + match(CAST); + setState(3471); + match(OPEN_PAREN); + setState(3472); + typename(); + setState(3473); + match(AS); + setState(3474); + typename(); + setState(3475); + match(CLOSE_PAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(3477); + match(ALTER); + setState(3478); + match(EXTENSION); + setState(3479); + name(); + setState(3480); + add_drop(); + setState(3481); + match(DOMAIN_P); + setState(3482); + typename(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(3484); + match(ALTER); + setState(3485); + match(EXTENSION); + setState(3486); + name(); + setState(3487); + add_drop(); + setState(3488); + match(FUNCTION); + setState(3489); + function_with_argtypes(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(3491); + match(ALTER); + setState(3492); + match(EXTENSION); + setState(3493); + name(); + setState(3494); + add_drop(); + setState(3495); + match(OPERATOR); + setState(3496); + operator_with_argtypes(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(3498); + match(ALTER); + setState(3499); + match(EXTENSION); + setState(3500); + name(); + setState(3501); + add_drop(); + setState(3502); + match(OPERATOR); + setState(3503); + match(CLASS); + setState(3504); + any_name(); + setState(3505); + match(USING); + setState(3506); + name(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(3508); + match(ALTER); + setState(3509); + match(EXTENSION); + setState(3510); + name(); + setState(3511); + add_drop(); + setState(3512); + match(OPERATOR); + setState(3513); + match(FAMILY); + setState(3514); + any_name(); + setState(3515); + match(USING); + setState(3516); + name(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(3518); + match(ALTER); + setState(3519); + match(EXTENSION); + setState(3520); + name(); + setState(3521); + add_drop(); + setState(3522); + match(PROCEDURE); + setState(3523); + function_with_argtypes(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(3525); + match(ALTER); + setState(3526); + match(EXTENSION); + setState(3527); + name(); + setState(3528); + add_drop(); + setState(3529); + match(ROUTINE); + setState(3530); + function_with_argtypes(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(3532); + match(ALTER); + setState(3533); + match(EXTENSION); + setState(3534); + name(); + setState(3535); + add_drop(); + setState(3536); + match(TRANSFORM); + setState(3537); + match(FOR); + setState(3538); + typename(); + setState(3539); + match(LANGUAGE); + setState(3540); + name(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(3542); + match(ALTER); + setState(3543); + match(EXTENSION); + setState(3544); + name(); + setState(3545); + add_drop(); + setState(3546); + match(TYPE_P); + setState(3547); + typename(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatefdwstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_fdw_optionsContext opt_fdw_options() { + return getRuleContext(Opt_fdw_optionsContext.class,0); + } + public Create_generic_optionsContext create_generic_options() { + return getRuleContext(Create_generic_optionsContext.class,0); + } + public CreatefdwstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createfdwstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatefdwstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatefdwstmt(this); + } + } + + public final CreatefdwstmtContext createfdwstmt() throws RecognitionException { + CreatefdwstmtContext _localctx = new CreatefdwstmtContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_createfdwstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3551); + match(CREATE); + setState(3552); + match(FOREIGN); + setState(3553); + match(DATA_P); + setState(3554); + match(WRAPPER); + setState(3555); + name(); + setState(3556); + opt_fdw_options(); + setState(3557); + create_generic_options(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fdw_optionContext extends ParserRuleContext { + public TerminalNode HANDLER() { return getToken(PostgreSqlParser.HANDLER, 0); } + public Handler_nameContext handler_name() { + return getRuleContext(Handler_nameContext.class,0); + } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode VALIDATOR() { return getToken(PostgreSqlParser.VALIDATOR, 0); } + public Fdw_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fdw_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFdw_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFdw_option(this); + } + } + + public final Fdw_optionContext fdw_option() throws RecognitionException { + Fdw_optionContext _localctx = new Fdw_optionContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_fdw_option); + try { + setState(3567); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3559); + match(HANDLER); + setState(3560); + handler_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3561); + match(NO); + setState(3562); + match(HANDLER); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3563); + match(VALIDATOR); + setState(3564); + handler_name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3565); + match(NO); + setState(3566); + match(VALIDATOR); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fdw_optionsContext extends ParserRuleContext { + public List fdw_option() { + return getRuleContexts(Fdw_optionContext.class); + } + public Fdw_optionContext fdw_option(int i) { + return getRuleContext(Fdw_optionContext.class,i); + } + public Fdw_optionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fdw_options; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFdw_options(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFdw_options(this); + } + } + + public final Fdw_optionsContext fdw_options() throws RecognitionException { + Fdw_optionsContext _localctx = new Fdw_optionsContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_fdw_options); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3570); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(3569); + fdw_option(); + } + } + setState(3572); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==HANDLER || _la==NO || _la==VALIDATOR ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_fdw_optionsContext extends ParserRuleContext { + public Fdw_optionsContext fdw_options() { + return getRuleContext(Fdw_optionsContext.class,0); + } + public Opt_fdw_optionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_fdw_options; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_fdw_options(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_fdw_options(this); + } + } + + public final Opt_fdw_optionsContext opt_fdw_options() throws RecognitionException { + Opt_fdw_optionsContext _localctx = new Opt_fdw_optionsContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_opt_fdw_options); + try { + setState(3576); + _errHandler.sync(this); + switch (_input.LA(1)) { + case HANDLER: + case NO: + case VALIDATOR: + enterOuterAlt(_localctx, 1); + { + setState(3574); + fdw_options(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case OPTIONS: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterfdwstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_fdw_optionsContext opt_fdw_options() { + return getRuleContext(Opt_fdw_optionsContext.class,0); + } + public Alter_generic_optionsContext alter_generic_options() { + return getRuleContext(Alter_generic_optionsContext.class,0); + } + public Fdw_optionsContext fdw_options() { + return getRuleContext(Fdw_optionsContext.class,0); + } + public AlterfdwstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterfdwstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterfdwstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterfdwstmt(this); + } + } + + public final AlterfdwstmtContext alterfdwstmt() throws RecognitionException { + AlterfdwstmtContext _localctx = new AlterfdwstmtContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_alterfdwstmt); + try { + setState(3593); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3578); + match(ALTER); + setState(3579); + match(FOREIGN); + setState(3580); + match(DATA_P); + setState(3581); + match(WRAPPER); + setState(3582); + name(); + setState(3583); + opt_fdw_options(); + setState(3584); + alter_generic_options(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3586); + match(ALTER); + setState(3587); + match(FOREIGN); + setState(3588); + match(DATA_P); + setState(3589); + match(WRAPPER); + setState(3590); + name(); + setState(3591); + fdw_options(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Create_generic_optionsContext extends ParserRuleContext { + public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Generic_option_listContext generic_option_list() { + return getRuleContext(Generic_option_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Create_generic_optionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_create_generic_options; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreate_generic_options(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreate_generic_options(this); + } + } + + public final Create_generic_optionsContext create_generic_options() throws RecognitionException { + Create_generic_optionsContext _localctx = new Create_generic_optionsContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_create_generic_options); + try { + setState(3601); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPTIONS: + enterOuterAlt(_localctx, 1); + { + setState(3595); + match(OPTIONS); + setState(3596); + match(OPEN_PAREN); + setState(3597); + generic_option_list(); + setState(3598); + match(CLOSE_PAREN); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CHECK: + case COLLATE: + case CONSTRAINT: + case CREATE: + case DEFAULT: + case DEFERRABLE: + case DO: + case FETCH: + case GRANT: + case INITIALLY: + case INTO: + case NOT: + case NULL_P: + case PRIMARY: + case REFERENCES: + case SELECT: + case TABLE: + case UNIQUE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case GENERATED: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Generic_option_listContext extends ParserRuleContext { + public List generic_option_elem() { + return getRuleContexts(Generic_option_elemContext.class); + } + public Generic_option_elemContext generic_option_elem(int i) { + return getRuleContext(Generic_option_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Generic_option_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generic_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGeneric_option_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGeneric_option_list(this); + } + } + + public final Generic_option_listContext generic_option_list() throws RecognitionException { + Generic_option_listContext _localctx = new Generic_option_listContext(_ctx, getState()); + enterRule(_localctx, 342, RULE_generic_option_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3603); + generic_option_elem(); + setState(3608); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3604); + match(COMMA); + setState(3605); + generic_option_elem(); + } + } + setState(3610); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_generic_optionsContext extends ParserRuleContext { + public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Alter_generic_option_listContext alter_generic_option_list() { + return getRuleContext(Alter_generic_option_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Alter_generic_optionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_generic_options; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_generic_options(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_generic_options(this); + } + } + + public final Alter_generic_optionsContext alter_generic_options() throws RecognitionException { + Alter_generic_optionsContext _localctx = new Alter_generic_optionsContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_alter_generic_options); + try { + enterOuterAlt(_localctx, 1); + { + setState(3611); + match(OPTIONS); + setState(3612); + match(OPEN_PAREN); + setState(3613); + alter_generic_option_list(); + setState(3614); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_generic_option_listContext extends ParserRuleContext { + public List alter_generic_option_elem() { + return getRuleContexts(Alter_generic_option_elemContext.class); + } + public Alter_generic_option_elemContext alter_generic_option_elem(int i) { + return getRuleContext(Alter_generic_option_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Alter_generic_option_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_generic_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_generic_option_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_generic_option_list(this); + } + } + + public final Alter_generic_option_listContext alter_generic_option_list() throws RecognitionException { + Alter_generic_option_listContext _localctx = new Alter_generic_option_listContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_alter_generic_option_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3616); + alter_generic_option_elem(); + setState(3621); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3617); + match(COMMA); + setState(3618); + alter_generic_option_elem(); + } + } + setState(3623); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alter_generic_option_elemContext extends ParserRuleContext { + public Generic_option_elemContext generic_option_elem() { + return getRuleContext(Generic_option_elemContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public Generic_option_nameContext generic_option_name() { + return getRuleContext(Generic_option_nameContext.class,0); + } + public Alter_generic_option_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alter_generic_option_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlter_generic_option_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlter_generic_option_elem(this); + } + } + + public final Alter_generic_option_elemContext alter_generic_option_elem() throws RecognitionException { + Alter_generic_option_elemContext _localctx = new Alter_generic_option_elemContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_alter_generic_option_elem); + try { + setState(3631); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3624); + generic_option_elem(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3625); + match(SET); + setState(3626); + generic_option_elem(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3627); + match(ADD_P); + setState(3628); + generic_option_elem(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3629); + match(DROP); + setState(3630); + generic_option_name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Generic_option_elemContext extends ParserRuleContext { + public Generic_option_nameContext generic_option_name() { + return getRuleContext(Generic_option_nameContext.class,0); + } + public Generic_option_argContext generic_option_arg() { + return getRuleContext(Generic_option_argContext.class,0); + } + public Generic_option_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generic_option_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGeneric_option_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGeneric_option_elem(this); + } + } + + public final Generic_option_elemContext generic_option_elem() throws RecognitionException { + Generic_option_elemContext _localctx = new Generic_option_elemContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_generic_option_elem); + try { + enterOuterAlt(_localctx, 1); + { + setState(3633); + generic_option_name(); + setState(3634); + generic_option_arg(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Generic_option_nameContext extends ParserRuleContext { + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public Generic_option_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generic_option_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGeneric_option_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGeneric_option_name(this); + } + } + + public final Generic_option_nameContext generic_option_name() throws RecognitionException { + Generic_option_nameContext _localctx = new Generic_option_nameContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_generic_option_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(3636); + collabel(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Generic_option_argContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Generic_option_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generic_option_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGeneric_option_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGeneric_option_arg(this); + } + } + + public final Generic_option_argContext generic_option_arg() throws RecognitionException { + Generic_option_argContext _localctx = new Generic_option_argContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_generic_option_arg); + try { + enterOuterAlt(_localctx, 1); + { + setState(3638); + sconst(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateforeignserverstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); + } + public Opt_typeContext opt_type() { + return getRuleContext(Opt_typeContext.class,0); + } + public Opt_foreign_server_versionContext opt_foreign_server_version() { + return getRuleContext(Opt_foreign_server_versionContext.class,0); + } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } + public Create_generic_optionsContext create_generic_options() { + return getRuleContext(Create_generic_optionsContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreateforeignserverstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createforeignserverstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateforeignserverstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateforeignserverstmt(this); + } + } + + public final CreateforeignserverstmtContext createforeignserverstmt() throws RecognitionException { + CreateforeignserverstmtContext _localctx = new CreateforeignserverstmtContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_createforeignserverstmt); + try { + setState(3665); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3640); + match(CREATE); + setState(3641); + match(SERVER); + setState(3642); + name(); + setState(3643); + opt_type(); + setState(3644); + opt_foreign_server_version(); + setState(3645); + match(FOREIGN); + setState(3646); + match(DATA_P); + setState(3647); + match(WRAPPER); + setState(3648); + name(); + setState(3649); + create_generic_options(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3651); + match(CREATE); + setState(3652); + match(SERVER); + setState(3653); + match(IF_P); + setState(3654); + match(NOT); + setState(3655); + match(EXISTS); + setState(3656); + name(); + setState(3657); + opt_type(); + setState(3658); + opt_foreign_server_version(); + setState(3659); + match(FOREIGN); + setState(3660); + match(DATA_P); + setState(3661); + match(WRAPPER); + setState(3662); + name(); + setState(3663); + create_generic_options(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_typeContext extends ParserRuleContext { + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Opt_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_type(this); + } + } + + public final Opt_typeContext opt_type() throws RecognitionException { + Opt_typeContext _localctx = new Opt_typeContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_opt_type); + try { + setState(3670); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TYPE_P: + enterOuterAlt(_localctx, 1); + { + setState(3667); + match(TYPE_P); + setState(3668); + sconst(); + } + break; + case FOREIGN: + case VERSION_P: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Foreign_server_versionContext extends ParserRuleContext { + public TerminalNode VERSION_P() { return getToken(PostgreSqlParser.VERSION_P, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public Foreign_server_versionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_foreign_server_version; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterForeign_server_version(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitForeign_server_version(this); + } + } + + public final Foreign_server_versionContext foreign_server_version() throws RecognitionException { + Foreign_server_versionContext _localctx = new Foreign_server_versionContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_foreign_server_version); + try { + enterOuterAlt(_localctx, 1); + { + setState(3672); + match(VERSION_P); + setState(3675); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + { + setState(3673); + sconst(); + } + break; + case NULL_P: + { + setState(3674); + match(NULL_P); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_foreign_server_versionContext extends ParserRuleContext { + public Foreign_server_versionContext foreign_server_version() { + return getRuleContext(Foreign_server_versionContext.class,0); + } + public Opt_foreign_server_versionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_foreign_server_version; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_foreign_server_version(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_foreign_server_version(this); + } + } + + public final Opt_foreign_server_versionContext opt_foreign_server_version() throws RecognitionException { + Opt_foreign_server_versionContext _localctx = new Opt_foreign_server_versionContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_opt_foreign_server_version); + try { + setState(3679); + _errHandler.sync(this); + switch (_input.LA(1)) { + case VERSION_P: + enterOuterAlt(_localctx, 1); + { + setState(3677); + foreign_server_version(); + } + break; + case FOREIGN: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterforeignserverstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Alter_generic_optionsContext alter_generic_options() { + return getRuleContext(Alter_generic_optionsContext.class,0); + } + public Foreign_server_versionContext foreign_server_version() { + return getRuleContext(Foreign_server_versionContext.class,0); + } + public AlterforeignserverstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterforeignserverstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterforeignserverstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterforeignserverstmt(this); + } + } + + public final AlterforeignserverstmtContext alterforeignserverstmt() throws RecognitionException { + AlterforeignserverstmtContext _localctx = new AlterforeignserverstmtContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_alterforeignserverstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3681); + match(ALTER); + setState(3682); + match(SERVER); + setState(3683); + name(); + setState(3689); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPTIONS: + { + setState(3684); + alter_generic_options(); + } + break; + case VERSION_P: + { + setState(3685); + foreign_server_version(); + setState(3687); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPTIONS) { + { + setState(3686); + alter_generic_options(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateforeigntablestmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public List qualified_name() { + return getRuleContexts(Qualified_nameContext.class); + } + public Qualified_nameContext qualified_name(int i) { + return getRuleContext(Qualified_nameContext.class,i); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public OpttableelementlistContext opttableelementlist() { + return getRuleContext(OpttableelementlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public OptinheritContext optinherit() { + return getRuleContext(OptinheritContext.class,0); + } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Create_generic_optionsContext create_generic_options() { + return getRuleContext(Create_generic_optionsContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public OpttypedtableelementlistContext opttypedtableelementlist() { + return getRuleContext(OpttypedtableelementlistContext.class,0); + } + public PartitionboundspecContext partitionboundspec() { + return getRuleContext(PartitionboundspecContext.class,0); + } + public CreateforeigntablestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createforeigntablestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateforeigntablestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateforeigntablestmt(this); + } + } + + public final CreateforeigntablestmtContext createforeigntablestmt() throws RecognitionException { + CreateforeigntablestmtContext _localctx = new CreateforeigntablestmtContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_createforeigntablestmt); + try { + setState(3747); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3691); + match(CREATE); + setState(3692); + match(FOREIGN); + setState(3693); + match(TABLE); + setState(3694); + qualified_name(); + setState(3695); + match(OPEN_PAREN); + setState(3696); + opttableelementlist(); + setState(3697); + match(CLOSE_PAREN); + setState(3698); + optinherit(); + setState(3699); + match(SERVER); + setState(3700); + name(); + setState(3701); + create_generic_options(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3703); + match(CREATE); + setState(3704); + match(FOREIGN); + setState(3705); + match(TABLE); + setState(3706); + match(IF_P); + setState(3707); + match(NOT); + setState(3708); + match(EXISTS); + setState(3709); + qualified_name(); + setState(3710); + match(OPEN_PAREN); + setState(3711); + opttableelementlist(); + setState(3712); + match(CLOSE_PAREN); + setState(3713); + optinherit(); + setState(3714); + match(SERVER); + setState(3715); + name(); + setState(3716); + create_generic_options(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3718); + match(CREATE); + setState(3719); + match(FOREIGN); + setState(3720); + match(TABLE); + setState(3721); + qualified_name(); + setState(3722); + match(PARTITION); + setState(3723); + match(OF); + setState(3724); + qualified_name(); + setState(3725); + opttypedtableelementlist(); + setState(3726); + partitionboundspec(); + setState(3727); + match(SERVER); + setState(3728); + name(); + setState(3729); + create_generic_options(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3731); + match(CREATE); + setState(3732); + match(FOREIGN); + setState(3733); + match(TABLE); + setState(3734); + match(IF_P); + setState(3735); + match(NOT); + setState(3736); + match(EXISTS); + setState(3737); + qualified_name(); + setState(3738); + match(PARTITION); + setState(3739); + match(OF); + setState(3740); + qualified_name(); + setState(3741); + opttypedtableelementlist(); + setState(3742); + partitionboundspec(); + setState(3743); + match(SERVER); + setState(3744); + name(); + setState(3745); + create_generic_options(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImportforeignschemastmtContext extends ParserRuleContext { + public TerminalNode IMPORT_P() { return getToken(PostgreSqlParser.IMPORT_P, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); + } + public Import_qualificationContext import_qualification() { + return getRuleContext(Import_qualificationContext.class,0); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } + public Create_generic_optionsContext create_generic_options() { + return getRuleContext(Create_generic_optionsContext.class,0); + } + public ImportforeignschemastmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importforeignschemastmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterImportforeignschemastmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitImportforeignschemastmt(this); + } + } + + public final ImportforeignschemastmtContext importforeignschemastmt() throws RecognitionException { + ImportforeignschemastmtContext _localctx = new ImportforeignschemastmtContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_importforeignschemastmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3749); + match(IMPORT_P); + setState(3750); + match(FOREIGN); + setState(3751); + match(SCHEMA); + setState(3752); + name(); + setState(3753); + import_qualification(); + setState(3754); + match(FROM); + setState(3755); + match(SERVER); + setState(3756); + name(); + setState(3757); + match(INTO); + setState(3758); + name(); + setState(3759); + create_generic_options(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Import_qualification_typeContext extends ParserRuleContext { + public TerminalNode LIMIT() { return getToken(PostgreSqlParser.LIMIT, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public TerminalNode EXCEPT() { return getToken(PostgreSqlParser.EXCEPT, 0); } + public Import_qualification_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_import_qualification_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterImport_qualification_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitImport_qualification_type(this); + } + } + + public final Import_qualification_typeContext import_qualification_type() throws RecognitionException { + Import_qualification_typeContext _localctx = new Import_qualification_typeContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_import_qualification_type); + try { + setState(3764); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LIMIT: + enterOuterAlt(_localctx, 1); + { + setState(3761); + match(LIMIT); + setState(3762); + match(TO); + } + break; + case EXCEPT: + enterOuterAlt(_localctx, 2); + { + setState(3763); + match(EXCEPT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Import_qualificationContext extends ParserRuleContext { + public Import_qualification_typeContext import_qualification_type() { + return getRuleContext(Import_qualification_typeContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Relation_expr_listContext relation_expr_list() { + return getRuleContext(Relation_expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Import_qualificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_import_qualification; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterImport_qualification(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitImport_qualification(this); + } + } + + public final Import_qualificationContext import_qualification() throws RecognitionException { + Import_qualificationContext _localctx = new Import_qualificationContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_import_qualification); + try { + setState(3772); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EXCEPT: + case LIMIT: + enterOuterAlt(_localctx, 1); + { + setState(3766); + import_qualification_type(); + setState(3767); + match(OPEN_PAREN); + setState(3768); + relation_expr_list(); + setState(3769); + match(CLOSE_PAREN); + } + break; + case FROM: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateusermappingstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode MAPPING() { return getToken(PostgreSqlParser.MAPPING, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Auth_identContext auth_ident() { + return getRuleContext(Auth_identContext.class,0); + } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Create_generic_optionsContext create_generic_options() { + return getRuleContext(Create_generic_optionsContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public CreateusermappingstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createusermappingstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateusermappingstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateusermappingstmt(this); + } + } + + public final CreateusermappingstmtContext createusermappingstmt() throws RecognitionException { + CreateusermappingstmtContext _localctx = new CreateusermappingstmtContext(_ctx, getState()); + enterRule(_localctx, 374, RULE_createusermappingstmt); + try { + setState(3795); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3774); + match(CREATE); + setState(3775); + match(USER); + setState(3776); + match(MAPPING); + setState(3777); + match(FOR); + setState(3778); + auth_ident(); + setState(3779); + match(SERVER); + setState(3780); + name(); + setState(3781); + create_generic_options(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3783); + match(CREATE); + setState(3784); + match(USER); + setState(3785); + match(MAPPING); + setState(3786); + match(IF_P); + setState(3787); + match(NOT); + setState(3788); + match(EXISTS); + setState(3789); + match(FOR); + setState(3790); + auth_ident(); + setState(3791); + match(SERVER); + setState(3792); + name(); + setState(3793); + create_generic_options(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Auth_identContext extends ParserRuleContext { + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public Auth_identContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_auth_ident; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAuth_ident(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAuth_ident(this); + } + } + + public final Auth_identContext auth_ident() throws RecognitionException { + Auth_identContext _localctx = new Auth_identContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_auth_ident); + try { + setState(3799); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_USER: + case DEFAULT: + case DO: + case FETCH: + case SESSION_USER: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(3797); + rolespec(); + } + break; + case USER: + enterOuterAlt(_localctx, 2); + { + setState(3798); + match(USER); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropusermappingstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode MAPPING() { return getToken(PostgreSqlParser.MAPPING, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Auth_identContext auth_ident() { + return getRuleContext(Auth_identContext.class,0); + } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public DropusermappingstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropusermappingstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDropusermappingstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDropusermappingstmt(this); + } + } + + public final DropusermappingstmtContext dropusermappingstmt() throws RecognitionException { + DropusermappingstmtContext _localctx = new DropusermappingstmtContext(_ctx, getState()); + enterRule(_localctx, 378, RULE_dropusermappingstmt); + try { + setState(3819); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3801); + match(DROP); + setState(3802); + match(USER); + setState(3803); + match(MAPPING); + setState(3804); + match(FOR); + setState(3805); + auth_ident(); + setState(3806); + match(SERVER); + setState(3807); + name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3809); + match(DROP); + setState(3810); + match(USER); + setState(3811); + match(MAPPING); + setState(3812); + match(IF_P); + setState(3813); + match(EXISTS); + setState(3814); + match(FOR); + setState(3815); + auth_ident(); + setState(3816); + match(SERVER); + setState(3817); + name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterusermappingstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode MAPPING() { return getToken(PostgreSqlParser.MAPPING, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Auth_identContext auth_ident() { + return getRuleContext(Auth_identContext.class,0); + } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Alter_generic_optionsContext alter_generic_options() { + return getRuleContext(Alter_generic_optionsContext.class,0); + } + public AlterusermappingstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterusermappingstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterusermappingstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterusermappingstmt(this); + } + } + + public final AlterusermappingstmtContext alterusermappingstmt() throws RecognitionException { + AlterusermappingstmtContext _localctx = new AlterusermappingstmtContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_alterusermappingstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3821); + match(ALTER); + setState(3822); + match(USER); + setState(3823); + match(MAPPING); + setState(3824); + match(FOR); + setState(3825); + auth_ident(); + setState(3826); + match(SERVER); + setState(3827); + name(); + setState(3828); + alter_generic_options(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatepolicystmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode POLICY() { return getToken(PostgreSqlParser.POLICY, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public RowsecuritydefaultpermissiveContext rowsecuritydefaultpermissive() { + return getRuleContext(RowsecuritydefaultpermissiveContext.class,0); + } + public RowsecuritydefaultforcmdContext rowsecuritydefaultforcmd() { + return getRuleContext(RowsecuritydefaultforcmdContext.class,0); + } + public RowsecuritydefaulttoroleContext rowsecuritydefaulttorole() { + return getRuleContext(RowsecuritydefaulttoroleContext.class,0); + } + public RowsecurityoptionalexprContext rowsecurityoptionalexpr() { + return getRuleContext(RowsecurityoptionalexprContext.class,0); + } + public RowsecurityoptionalwithcheckContext rowsecurityoptionalwithcheck() { + return getRuleContext(RowsecurityoptionalwithcheckContext.class,0); + } + public CreatepolicystmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createpolicystmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatepolicystmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatepolicystmt(this); + } + } + + public final CreatepolicystmtContext createpolicystmt() throws RecognitionException { + CreatepolicystmtContext _localctx = new CreatepolicystmtContext(_ctx, getState()); + enterRule(_localctx, 382, RULE_createpolicystmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3830); + match(CREATE); + setState(3831); + match(POLICY); + setState(3832); + name(); + setState(3833); + match(ON); + setState(3834); + qualified_name(); + setState(3835); + rowsecuritydefaultpermissive(); + setState(3836); + rowsecuritydefaultforcmd(); + setState(3837); + rowsecuritydefaulttorole(); + setState(3838); + rowsecurityoptionalexpr(); + setState(3839); + rowsecurityoptionalwithcheck(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterpolicystmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode POLICY() { return getToken(PostgreSqlParser.POLICY, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public RowsecurityoptionaltoroleContext rowsecurityoptionaltorole() { + return getRuleContext(RowsecurityoptionaltoroleContext.class,0); + } + public RowsecurityoptionalexprContext rowsecurityoptionalexpr() { + return getRuleContext(RowsecurityoptionalexprContext.class,0); + } + public RowsecurityoptionalwithcheckContext rowsecurityoptionalwithcheck() { + return getRuleContext(RowsecurityoptionalwithcheckContext.class,0); + } + public AlterpolicystmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterpolicystmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterpolicystmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterpolicystmt(this); + } + } + + public final AlterpolicystmtContext alterpolicystmt() throws RecognitionException { + AlterpolicystmtContext _localctx = new AlterpolicystmtContext(_ctx, getState()); + enterRule(_localctx, 384, RULE_alterpolicystmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3841); + match(ALTER); + setState(3842); + match(POLICY); + setState(3843); + name(); + setState(3844); + match(ON); + setState(3845); + qualified_name(); + setState(3846); + rowsecurityoptionaltorole(); + setState(3847); + rowsecurityoptionalexpr(); + setState(3848); + rowsecurityoptionalwithcheck(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RowsecurityoptionalexprContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public RowsecurityoptionalexprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rowsecurityoptionalexpr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRowsecurityoptionalexpr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRowsecurityoptionalexpr(this); + } + } + + public final RowsecurityoptionalexprContext rowsecurityoptionalexpr() throws RecognitionException { + RowsecurityoptionalexprContext _localctx = new RowsecurityoptionalexprContext(_ctx, getState()); + enterRule(_localctx, 386, RULE_rowsecurityoptionalexpr); + try { + setState(3856); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(3850); + match(USING); + setState(3851); + match(OPEN_PAREN); + setState(3852); + a_expr(); + setState(3853); + match(CLOSE_PAREN); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RowsecurityoptionalwithcheckContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public RowsecurityoptionalwithcheckContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rowsecurityoptionalwithcheck; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRowsecurityoptionalwithcheck(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRowsecurityoptionalwithcheck(this); + } + } + + public final RowsecurityoptionalwithcheckContext rowsecurityoptionalwithcheck() throws RecognitionException { + RowsecurityoptionalwithcheckContext _localctx = new RowsecurityoptionalwithcheckContext(_ctx, getState()); + enterRule(_localctx, 388, RULE_rowsecurityoptionalwithcheck); + try { + setState(3865); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3858); + match(WITH); + setState(3859); + match(CHECK); + setState(3860); + match(OPEN_PAREN); + setState(3861); + a_expr(); + setState(3862); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RowsecuritydefaulttoroleContext extends ParserRuleContext { + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public RowsecuritydefaulttoroleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rowsecuritydefaulttorole; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRowsecuritydefaulttorole(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRowsecuritydefaulttorole(this); + } + } + + public final RowsecuritydefaulttoroleContext rowsecuritydefaulttorole() throws RecognitionException { + RowsecuritydefaulttoroleContext _localctx = new RowsecuritydefaulttoroleContext(_ctx, getState()); + enterRule(_localctx, 390, RULE_rowsecuritydefaulttorole); + try { + setState(3870); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TO: + enterOuterAlt(_localctx, 1); + { + setState(3867); + match(TO); + setState(3868); + role_list(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case USING: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RowsecurityoptionaltoroleContext extends ParserRuleContext { + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public RowsecurityoptionaltoroleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rowsecurityoptionaltorole; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRowsecurityoptionaltorole(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRowsecurityoptionaltorole(this); + } + } + + public final RowsecurityoptionaltoroleContext rowsecurityoptionaltorole() throws RecognitionException { + RowsecurityoptionaltoroleContext _localctx = new RowsecurityoptionaltoroleContext(_ctx, getState()); + enterRule(_localctx, 392, RULE_rowsecurityoptionaltorole); + try { + setState(3875); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TO: + enterOuterAlt(_localctx, 1); + { + setState(3872); + match(TO); + setState(3873); + role_list(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case USING: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RowsecuritydefaultpermissiveContext extends ParserRuleContext { + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public RowsecuritydefaultpermissiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rowsecuritydefaultpermissive; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRowsecuritydefaultpermissive(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRowsecuritydefaultpermissive(this); + } + } + + public final RowsecuritydefaultpermissiveContext rowsecuritydefaultpermissive() throws RecognitionException { + RowsecuritydefaultpermissiveContext _localctx = new RowsecuritydefaultpermissiveContext(_ctx, getState()); + enterRule(_localctx, 394, RULE_rowsecuritydefaultpermissive); + try { + setState(3880); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AS: + enterOuterAlt(_localctx, 1); + { + setState(3877); + match(AS); + setState(3878); + identifier(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case FOR: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case TO: + case USING: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RowsecuritydefaultforcmdContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Row_security_cmdContext row_security_cmd() { + return getRuleContext(Row_security_cmdContext.class,0); + } + public RowsecuritydefaultforcmdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rowsecuritydefaultforcmd; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRowsecuritydefaultforcmd(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRowsecuritydefaultforcmd(this); + } + } + + public final RowsecuritydefaultforcmdContext rowsecuritydefaultforcmd() throws RecognitionException { + RowsecuritydefaultforcmdContext _localctx = new RowsecuritydefaultforcmdContext(_ctx, getState()); + enterRule(_localctx, 396, RULE_rowsecuritydefaultforcmd); + try { + setState(3885); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(3882); + match(FOR); + setState(3883); + row_security_cmd(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case TO: + case USING: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Row_security_cmdContext extends ParserRuleContext { + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } + public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public TerminalNode DELETE_P() { return getToken(PostgreSqlParser.DELETE_P, 0); } + public Row_security_cmdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_row_security_cmd; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRow_security_cmd(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRow_security_cmd(this); + } + } + + public final Row_security_cmdContext row_security_cmd() throws RecognitionException { + Row_security_cmdContext _localctx = new Row_security_cmdContext(_ctx, getState()); + enterRule(_localctx, 398, RULE_row_security_cmd); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3887); + _la = _input.LA(1); + if ( !(_la==ALL || _la==SELECT || _la==DELETE_P || _la==INSERT || _la==UPDATE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateamstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode ACCESS() { return getToken(PostgreSqlParser.ACCESS, 0); } + public TerminalNode METHOD() { return getToken(PostgreSqlParser.METHOD, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public Am_typeContext am_type() { + return getRuleContext(Am_typeContext.class,0); + } + public TerminalNode HANDLER() { return getToken(PostgreSqlParser.HANDLER, 0); } + public Handler_nameContext handler_name() { + return getRuleContext(Handler_nameContext.class,0); + } + public CreateamstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createamstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateamstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateamstmt(this); + } + } + + public final CreateamstmtContext createamstmt() throws RecognitionException { + CreateamstmtContext _localctx = new CreateamstmtContext(_ctx, getState()); + enterRule(_localctx, 400, RULE_createamstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(3889); + match(CREATE); + setState(3890); + match(ACCESS); + setState(3891); + match(METHOD); + setState(3892); + name(); + setState(3893); + match(TYPE_P); + setState(3894); + am_type(); + setState(3895); + match(HANDLER); + setState(3896); + handler_name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Am_typeContext extends ParserRuleContext { + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Am_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_am_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAm_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAm_type(this); + } + } + + public final Am_typeContext am_type() throws RecognitionException { + Am_typeContext _localctx = new Am_typeContext(_ctx, getState()); + enterRule(_localctx, 402, RULE_am_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3898); + _la = _input.LA(1); + if ( !(_la==TABLE || _la==INDEX) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatetrigstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TriggeractiontimeContext triggeractiontime() { + return getRuleContext(TriggeractiontimeContext.class,0); + } + public TriggereventsContext triggerevents() { + return getRuleContext(TriggereventsContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TriggerreferencingContext triggerreferencing() { + return getRuleContext(TriggerreferencingContext.class,0); + } + public TriggerforspecContext triggerforspec() { + return getRuleContext(TriggerforspecContext.class,0); + } + public TriggerwhenContext triggerwhen() { + return getRuleContext(TriggerwhenContext.class,0); + } + public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } + public Function_or_procedureContext function_or_procedure() { + return getRuleContext(Function_or_procedureContext.class,0); + } + public Func_nameContext func_name() { + return getRuleContext(Func_nameContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TriggerfuncargsContext triggerfuncargs() { + return getRuleContext(TriggerfuncargsContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public TerminalNode AFTER() { return getToken(PostgreSqlParser.AFTER, 0); } + public OptconstrfromtableContext optconstrfromtable() { + return getRuleContext(OptconstrfromtableContext.class,0); + } + public ConstraintattributespecContext constraintattributespec() { + return getRuleContext(ConstraintattributespecContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode EACH() { return getToken(PostgreSqlParser.EACH, 0); } + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public CreatetrigstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createtrigstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatetrigstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatetrigstmt(this); + } + } + + public final CreatetrigstmtContext createtrigstmt() throws RecognitionException { + CreatetrigstmtContext _localctx = new CreatetrigstmtContext(_ctx, getState()); + enterRule(_localctx, 404, RULE_createtrigstmt); + try { + setState(3938); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3900); + match(CREATE); + setState(3901); + match(TRIGGER); + setState(3902); + name(); + setState(3903); + triggeractiontime(); + setState(3904); + triggerevents(); + setState(3905); + match(ON); + setState(3906); + qualified_name(); + setState(3907); + triggerreferencing(); + setState(3908); + triggerforspec(); + setState(3909); + triggerwhen(); + setState(3910); + match(EXECUTE); + setState(3911); + function_or_procedure(); + setState(3912); + func_name(); + setState(3913); + match(OPEN_PAREN); + setState(3914); + triggerfuncargs(); + setState(3915); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3917); + match(CREATE); + setState(3918); + match(CONSTRAINT); + setState(3919); + match(TRIGGER); + setState(3920); + name(); + setState(3921); + match(AFTER); + setState(3922); + triggerevents(); + setState(3923); + match(ON); + setState(3924); + qualified_name(); + setState(3925); + optconstrfromtable(); + setState(3926); + constraintattributespec(); + setState(3927); + match(FOR); + setState(3928); + match(EACH); + setState(3929); + match(ROW); + setState(3930); + triggerwhen(); + setState(3931); + match(EXECUTE); + setState(3932); + function_or_procedure(); + setState(3933); + func_name(); + setState(3934); + match(OPEN_PAREN); + setState(3935); + triggerfuncargs(); + setState(3936); + match(CLOSE_PAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggeractiontimeContext extends ParserRuleContext { + public TerminalNode BEFORE() { return getToken(PostgreSqlParser.BEFORE, 0); } + public TerminalNode AFTER() { return getToken(PostgreSqlParser.AFTER, 0); } + public TerminalNode INSTEAD() { return getToken(PostgreSqlParser.INSTEAD, 0); } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public TriggeractiontimeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggeractiontime; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggeractiontime(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggeractiontime(this); + } + } + + public final TriggeractiontimeContext triggeractiontime() throws RecognitionException { + TriggeractiontimeContext _localctx = new TriggeractiontimeContext(_ctx, getState()); + enterRule(_localctx, 406, RULE_triggeractiontime); + try { + setState(3944); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BEFORE: + enterOuterAlt(_localctx, 1); + { + setState(3940); + match(BEFORE); + } + break; + case AFTER: + enterOuterAlt(_localctx, 2); + { + setState(3941); + match(AFTER); + } + break; + case INSTEAD: + enterOuterAlt(_localctx, 3); + { + setState(3942); + match(INSTEAD); + setState(3943); + match(OF); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggereventsContext extends ParserRuleContext { + public List triggeroneevent() { + return getRuleContexts(TriggeroneeventContext.class); + } + public TriggeroneeventContext triggeroneevent(int i) { + return getRuleContext(TriggeroneeventContext.class,i); + } + public List OR() { return getTokens(PostgreSqlParser.OR); } + public TerminalNode OR(int i) { + return getToken(PostgreSqlParser.OR, i); + } + public TriggereventsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggerevents; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggerevents(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggerevents(this); + } + } + + public final TriggereventsContext triggerevents() throws RecognitionException { + TriggereventsContext _localctx = new TriggereventsContext(_ctx, getState()); + enterRule(_localctx, 408, RULE_triggerevents); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3946); + triggeroneevent(); + setState(3951); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OR) { + { + { + setState(3947); + match(OR); + setState(3948); + triggeroneevent(); + } + } + setState(3953); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggeroneeventContext extends ParserRuleContext { + public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } + public TerminalNode DELETE_P() { return getToken(PostgreSqlParser.DELETE_P, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public ColumnlistContext columnlist() { + return getRuleContext(ColumnlistContext.class,0); + } + public TerminalNode TRUNCATE() { return getToken(PostgreSqlParser.TRUNCATE, 0); } + public TriggeroneeventContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggeroneevent; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggeroneevent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggeroneevent(this); + } + } + + public final TriggeroneeventContext triggeroneevent() throws RecognitionException { + TriggeroneeventContext _localctx = new TriggeroneeventContext(_ctx, getState()); + enterRule(_localctx, 410, RULE_triggeroneevent); + try { + setState(3961); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3954); + match(INSERT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3955); + match(DELETE_P); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3956); + match(UPDATE); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3957); + match(UPDATE); + setState(3958); + match(OF); + setState(3959); + columnlist(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(3960); + match(TRUNCATE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggerreferencingContext extends ParserRuleContext { + public TerminalNode REFERENCING() { return getToken(PostgreSqlParser.REFERENCING, 0); } + public TriggertransitionsContext triggertransitions() { + return getRuleContext(TriggertransitionsContext.class,0); + } + public TriggerreferencingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggerreferencing; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggerreferencing(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggerreferencing(this); + } + } + + public final TriggerreferencingContext triggerreferencing() throws RecognitionException { + TriggerreferencingContext _localctx = new TriggerreferencingContext(_ctx, getState()); + enterRule(_localctx, 412, RULE_triggerreferencing); + try { + setState(3966); + _errHandler.sync(this); + switch (_input.LA(1)) { + case REFERENCING: + enterOuterAlt(_localctx, 1); + { + setState(3963); + match(REFERENCING); + setState(3964); + triggertransitions(); + } + break; + case FOR: + case WHEN: + case EXECUTE: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggertransitionsContext extends ParserRuleContext { + public List triggertransition() { + return getRuleContexts(TriggertransitionContext.class); + } + public TriggertransitionContext triggertransition(int i) { + return getRuleContext(TriggertransitionContext.class,i); + } + public TriggertransitionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggertransitions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggertransitions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggertransitions(this); + } + } + + public final TriggertransitionsContext triggertransitions() throws RecognitionException { + TriggertransitionsContext _localctx = new TriggertransitionsContext(_ctx, getState()); + enterRule(_localctx, 414, RULE_triggertransitions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3969); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(3968); + triggertransition(); + } + } + setState(3971); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==NEW || _la==OLD ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggertransitionContext extends ParserRuleContext { + public TransitionoldornewContext transitionoldornew() { + return getRuleContext(TransitionoldornewContext.class,0); + } + public TransitionrowortableContext transitionrowortable() { + return getRuleContext(TransitionrowortableContext.class,0); + } + public Opt_asContext opt_as() { + return getRuleContext(Opt_asContext.class,0); + } + public TransitionrelnameContext transitionrelname() { + return getRuleContext(TransitionrelnameContext.class,0); + } + public TriggertransitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggertransition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggertransition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggertransition(this); + } + } + + public final TriggertransitionContext triggertransition() throws RecognitionException { + TriggertransitionContext _localctx = new TriggertransitionContext(_ctx, getState()); + enterRule(_localctx, 416, RULE_triggertransition); + try { + enterOuterAlt(_localctx, 1); + { + setState(3973); + transitionoldornew(); + setState(3974); + transitionrowortable(); + setState(3975); + opt_as(); + setState(3976); + transitionrelname(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransitionoldornewContext extends ParserRuleContext { + public TerminalNode NEW() { return getToken(PostgreSqlParser.NEW, 0); } + public TerminalNode OLD() { return getToken(PostgreSqlParser.OLD, 0); } + public TransitionoldornewContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transitionoldornew; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransitionoldornew(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransitionoldornew(this); + } + } + + public final TransitionoldornewContext transitionoldornew() throws RecognitionException { + TransitionoldornewContext _localctx = new TransitionoldornewContext(_ctx, getState()); + enterRule(_localctx, 418, RULE_transitionoldornew); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3978); + _la = _input.LA(1); + if ( !(_la==NEW || _la==OLD) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransitionrowortableContext extends ParserRuleContext { + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TransitionrowortableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transitionrowortable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransitionrowortable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransitionrowortable(this); + } + } + + public final TransitionrowortableContext transitionrowortable() throws RecognitionException { + TransitionrowortableContext _localctx = new TransitionrowortableContext(_ctx, getState()); + enterRule(_localctx, 420, RULE_transitionrowortable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3980); + _la = _input.LA(1); + if ( !(_la==TABLE || _la==ROW) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransitionrelnameContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TransitionrelnameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transitionrelname; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransitionrelname(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransitionrelname(this); + } + } + + public final TransitionrelnameContext transitionrelname() throws RecognitionException { + TransitionrelnameContext _localctx = new TransitionrelnameContext(_ctx, getState()); + enterRule(_localctx, 422, RULE_transitionrelname); + try { + enterOuterAlt(_localctx, 1); + { + setState(3982); + colid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggerforspecContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TriggerforopteachContext triggerforopteach() { + return getRuleContext(TriggerforopteachContext.class,0); + } + public TriggerfortypeContext triggerfortype() { + return getRuleContext(TriggerfortypeContext.class,0); + } + public TriggerforspecContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggerforspec; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggerforspec(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggerforspec(this); + } + } + + public final TriggerforspecContext triggerforspec() throws RecognitionException { + TriggerforspecContext _localctx = new TriggerforspecContext(_ctx, getState()); + enterRule(_localctx, 424, RULE_triggerforspec); + try { + setState(3989); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(3984); + match(FOR); + setState(3985); + triggerforopteach(); + setState(3986); + triggerfortype(); + } + break; + case WHEN: + case EXECUTE: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggerforopteachContext extends ParserRuleContext { + public TerminalNode EACH() { return getToken(PostgreSqlParser.EACH, 0); } + public TriggerforopteachContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggerforopteach; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggerforopteach(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggerforopteach(this); + } + } + + public final TriggerforopteachContext triggerforopteach() throws RecognitionException { + TriggerforopteachContext _localctx = new TriggerforopteachContext(_ctx, getState()); + enterRule(_localctx, 426, RULE_triggerforopteach); + try { + setState(3993); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EACH: + enterOuterAlt(_localctx, 1); + { + setState(3991); + match(EACH); + } + break; + case STATEMENT: + case ROW: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggerfortypeContext extends ParserRuleContext { + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TerminalNode STATEMENT() { return getToken(PostgreSqlParser.STATEMENT, 0); } + public TriggerfortypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggerfortype; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggerfortype(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggerfortype(this); + } + } + + public final TriggerfortypeContext triggerfortype() throws RecognitionException { + TriggerfortypeContext _localctx = new TriggerfortypeContext(_ctx, getState()); + enterRule(_localctx, 428, RULE_triggerfortype); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3995); + _la = _input.LA(1); + if ( !(_la==STATEMENT || _la==ROW) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggerwhenContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TriggerwhenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggerwhen; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggerwhen(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggerwhen(this); + } + } + + public final TriggerwhenContext triggerwhen() throws RecognitionException { + TriggerwhenContext _localctx = new TriggerwhenContext(_ctx, getState()); + enterRule(_localctx, 430, RULE_triggerwhen); + try { + setState(4003); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WHEN: + enterOuterAlt(_localctx, 1); + { + setState(3997); + match(WHEN); + setState(3998); + match(OPEN_PAREN); + setState(3999); + a_expr(); + setState(4000); + match(CLOSE_PAREN); + } + break; + case EXECUTE: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Function_or_procedureContext extends ParserRuleContext { + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public Function_or_procedureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_function_or_procedure; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunction_or_procedure(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunction_or_procedure(this); + } + } + + public final Function_or_procedureContext function_or_procedure() throws RecognitionException { + Function_or_procedureContext _localctx = new Function_or_procedureContext(_ctx, getState()); + enterRule(_localctx, 432, RULE_function_or_procedure); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4005); + _la = _input.LA(1); + if ( !(_la==FUNCTION || _la==PROCEDURE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggerfuncargsContext extends ParserRuleContext { + public List triggerfuncarg() { + return getRuleContexts(TriggerfuncargContext.class); + } + public TriggerfuncargContext triggerfuncarg(int i) { + return getRuleContext(TriggerfuncargContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public TriggerfuncargsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggerfuncargs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggerfuncargs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggerfuncargs(this); + } + } + + public final TriggerfuncargsContext triggerfuncargs() throws RecognitionException { + TriggerfuncargsContext _localctx = new TriggerfuncargsContext(_ctx, getState()); + enterRule(_localctx, 434, RULE_triggerfuncargs); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4009); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALL: + case ANALYSE: + case ANALYZE: + case AND: + case ANY: + case ARRAY: + case AS: + case ASC: + case ASYMMETRIC: + case BOTH: + case CASE: + case CAST: + case CHECK: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CREATE: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DEFERRABLE: + case DESC: + case DISTINCT: + case DO: + case ELSE: + case EXCEPT: + case FALSE_P: + case FETCH: + case FOR: + case FOREIGN: + case FROM: + case GRANT: + case GROUP_P: + case HAVING: + case IN_P: + case INITIALLY: + case INTERSECT: + case LATERAL_P: + case LEADING: + case LIMIT: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case OFFSET: + case ON: + case ONLY: + case OR: + case ORDER: + case PLACING: + case PRIMARY: + case REFERENCES: + case RETURNING: + case SELECT: + case SESSION_USER: + case SOME: + case SYMMETRIC: + case TABLE: + case THEN: + case TO: + case TRAILING: + case TRUE_P: + case UNION: + case UNIQUE: + case USER: + case USING: + case VARIADIC: + case WHEN: + case WHERE: + case WINDOW: + case WITH: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case END_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + { + setState(4007); + triggerfuncarg(); + } + break; + case CLOSE_PAREN: + case COMMA: + { + } + break; + default: + throw new NoViableAltException(this); + } + setState(4015); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4011); + match(COMMA); + setState(4012); + triggerfuncarg(); + } + } + setState(4017); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TriggerfuncargContext extends ParserRuleContext { + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public FconstContext fconst() { + return getRuleContext(FconstContext.class,0); + } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public TriggerfuncargContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_triggerfuncarg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTriggerfuncarg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTriggerfuncarg(this); + } + } + + public final TriggerfuncargContext triggerfuncarg() throws RecognitionException { + TriggerfuncargContext _localctx = new TriggerfuncargContext(_ctx, getState()); + enterRule(_localctx, 436, RULE_triggerfuncarg); + try { + setState(4022); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Integral: + enterOuterAlt(_localctx, 1); + { + setState(4018); + iconst(); + } + break; + case Numeric: + enterOuterAlt(_localctx, 2); + { + setState(4019); + fconst(); + } + break; + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 3); + { + setState(4020); + sconst(); + } + break; + case ALL: + case ANALYSE: + case ANALYZE: + case AND: + case ANY: + case ARRAY: + case AS: + case ASC: + case ASYMMETRIC: + case BOTH: + case CASE: + case CAST: + case CHECK: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CREATE: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DEFERRABLE: + case DESC: + case DISTINCT: + case DO: + case ELSE: + case EXCEPT: + case FALSE_P: + case FETCH: + case FOR: + case FOREIGN: + case FROM: + case GRANT: + case GROUP_P: + case HAVING: + case IN_P: + case INITIALLY: + case INTERSECT: + case LATERAL_P: + case LEADING: + case LIMIT: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case OFFSET: + case ON: + case ONLY: + case OR: + case ORDER: + case PLACING: + case PRIMARY: + case REFERENCES: + case RETURNING: + case SELECT: + case SESSION_USER: + case SOME: + case SYMMETRIC: + case TABLE: + case THEN: + case TO: + case TRAILING: + case TRUE_P: + case UNION: + case UNIQUE: + case USER: + case USING: + case VARIADIC: + case WHEN: + case WHERE: + case WINDOW: + case WITH: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case END_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 4); + { + setState(4021); + collabel(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OptconstrfromtableContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public OptconstrfromtableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_optconstrfromtable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOptconstrfromtable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOptconstrfromtable(this); + } + } + + public final OptconstrfromtableContext optconstrfromtable() throws RecognitionException { + OptconstrfromtableContext _localctx = new OptconstrfromtableContext(_ctx, getState()); + enterRule(_localctx, 438, RULE_optconstrfromtable); + try { + setState(4027); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FROM: + enterOuterAlt(_localctx, 1); + { + setState(4024); + match(FROM); + setState(4025); + qualified_name(); + } + break; + case DEFERRABLE: + case FOR: + case INITIALLY: + case NOT: + case NO: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstraintattributespecContext extends ParserRuleContext { + public List constraintattributeElem() { + return getRuleContexts(ConstraintattributeElemContext.class); + } + public ConstraintattributeElemContext constraintattributeElem(int i) { + return getRuleContext(ConstraintattributeElemContext.class,i); + } + public ConstraintattributespecContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constraintattributespec; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstraintattributespec(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstraintattributespec(this); + } + } + + public final ConstraintattributespecContext constraintattributespec() throws RecognitionException { + ConstraintattributespecContext _localctx = new ConstraintattributespecContext(_ctx, getState()); + enterRule(_localctx, 440, RULE_constraintattributespec); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4032); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 56)) & ~0x3f) == 0 && ((1L << (_la - 56)) & 8421377L) != 0) || _la==NO) { + { + { + setState(4029); + constraintattributeElem(); + } + } + setState(4034); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstraintattributeElemContext extends ParserRuleContext { + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode DEFERRABLE() { return getToken(PostgreSqlParser.DEFERRABLE, 0); } + public TerminalNode INITIALLY() { return getToken(PostgreSqlParser.INITIALLY, 0); } + public TerminalNode IMMEDIATE() { return getToken(PostgreSqlParser.IMMEDIATE, 0); } + public TerminalNode DEFERRED() { return getToken(PostgreSqlParser.DEFERRED, 0); } + public TerminalNode VALID() { return getToken(PostgreSqlParser.VALID, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode INHERIT() { return getToken(PostgreSqlParser.INHERIT, 0); } + public ConstraintattributeElemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constraintattributeElem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstraintattributeElem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstraintattributeElem(this); + } + } + + public final ConstraintattributeElemContext constraintattributeElem() throws RecognitionException { + ConstraintattributeElemContext _localctx = new ConstraintattributeElemContext(_ctx, getState()); + enterRule(_localctx, 442, RULE_constraintattributeElem); + try { + setState(4046); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4035); + match(NOT); + setState(4036); + match(DEFERRABLE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4037); + match(DEFERRABLE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4038); + match(INITIALLY); + setState(4039); + match(IMMEDIATE); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4040); + match(INITIALLY); + setState(4041); + match(DEFERRED); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4042); + match(NOT); + setState(4043); + match(VALID); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(4044); + match(NO); + setState(4045); + match(INHERIT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateeventtrigstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } + public Function_or_procedureContext function_or_procedure() { + return getRuleContext(Function_or_procedureContext.class,0); + } + public Func_nameContext func_name() { + return getRuleContext(Func_nameContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public Event_trigger_when_listContext event_trigger_when_list() { + return getRuleContext(Event_trigger_when_listContext.class,0); + } + public CreateeventtrigstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createeventtrigstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateeventtrigstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateeventtrigstmt(this); + } + } + + public final CreateeventtrigstmtContext createeventtrigstmt() throws RecognitionException { + CreateeventtrigstmtContext _localctx = new CreateeventtrigstmtContext(_ctx, getState()); + enterRule(_localctx, 444, RULE_createeventtrigstmt); + try { + setState(4074); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4048); + match(CREATE); + setState(4049); + match(EVENT); + setState(4050); + match(TRIGGER); + setState(4051); + name(); + setState(4052); + match(ON); + setState(4053); + collabel(); + setState(4054); + match(EXECUTE); + setState(4055); + function_or_procedure(); + setState(4056); + func_name(); + setState(4057); + match(OPEN_PAREN); + setState(4058); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4060); + match(CREATE); + setState(4061); + match(EVENT); + setState(4062); + match(TRIGGER); + setState(4063); + name(); + setState(4064); + match(ON); + setState(4065); + collabel(); + setState(4066); + match(WHEN); + setState(4067); + event_trigger_when_list(); + setState(4068); + match(EXECUTE); + setState(4069); + function_or_procedure(); + setState(4070); + func_name(); + setState(4071); + match(OPEN_PAREN); + setState(4072); + match(CLOSE_PAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Event_trigger_when_listContext extends ParserRuleContext { + public List event_trigger_when_item() { + return getRuleContexts(Event_trigger_when_itemContext.class); + } + public Event_trigger_when_itemContext event_trigger_when_item(int i) { + return getRuleContext(Event_trigger_when_itemContext.class,i); + } + public List AND() { return getTokens(PostgreSqlParser.AND); } + public TerminalNode AND(int i) { + return getToken(PostgreSqlParser.AND, i); + } + public Event_trigger_when_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_event_trigger_when_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterEvent_trigger_when_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitEvent_trigger_when_list(this); + } + } + + public final Event_trigger_when_listContext event_trigger_when_list() throws RecognitionException { + Event_trigger_when_listContext _localctx = new Event_trigger_when_listContext(_ctx, getState()); + enterRule(_localctx, 446, RULE_event_trigger_when_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4076); + event_trigger_when_item(); + setState(4081); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AND) { + { + { + setState(4077); + match(AND); + setState(4078); + event_trigger_when_item(); + } + } + setState(4083); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Event_trigger_when_itemContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Event_trigger_value_listContext event_trigger_value_list() { + return getRuleContext(Event_trigger_value_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Event_trigger_when_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_event_trigger_when_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterEvent_trigger_when_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitEvent_trigger_when_item(this); + } + } + + public final Event_trigger_when_itemContext event_trigger_when_item() throws RecognitionException { + Event_trigger_when_itemContext _localctx = new Event_trigger_when_itemContext(_ctx, getState()); + enterRule(_localctx, 448, RULE_event_trigger_when_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(4084); + colid(); + setState(4085); + match(IN_P); + setState(4086); + match(OPEN_PAREN); + setState(4087); + event_trigger_value_list(); + setState(4088); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Event_trigger_value_listContext extends ParserRuleContext { + public List sconst() { + return getRuleContexts(SconstContext.class); + } + public SconstContext sconst(int i) { + return getRuleContext(SconstContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Event_trigger_value_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_event_trigger_value_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterEvent_trigger_value_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitEvent_trigger_value_list(this); + } + } + + public final Event_trigger_value_listContext event_trigger_value_list() throws RecognitionException { + Event_trigger_value_listContext _localctx = new Event_trigger_value_listContext(_ctx, getState()); + enterRule(_localctx, 450, RULE_event_trigger_value_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4090); + sconst(); + setState(4095); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4091); + match(COMMA); + setState(4092); + sconst(); + } + } + setState(4097); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltereventtrigstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Enable_triggerContext enable_trigger() { + return getRuleContext(Enable_triggerContext.class,0); + } + public AltereventtrigstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altereventtrigstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltereventtrigstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltereventtrigstmt(this); + } + } + + public final AltereventtrigstmtContext altereventtrigstmt() throws RecognitionException { + AltereventtrigstmtContext _localctx = new AltereventtrigstmtContext(_ctx, getState()); + enterRule(_localctx, 452, RULE_altereventtrigstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(4098); + match(ALTER); + setState(4099); + match(EVENT); + setState(4100); + match(TRIGGER); + setState(4101); + name(); + setState(4102); + enable_trigger(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Enable_triggerContext extends ParserRuleContext { + public TerminalNode ENABLE_P() { return getToken(PostgreSqlParser.ENABLE_P, 0); } + public TerminalNode REPLICA() { return getToken(PostgreSqlParser.REPLICA, 0); } + public TerminalNode ALWAYS() { return getToken(PostgreSqlParser.ALWAYS, 0); } + public TerminalNode DISABLE_P() { return getToken(PostgreSqlParser.DISABLE_P, 0); } + public Enable_triggerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enable_trigger; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterEnable_trigger(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitEnable_trigger(this); + } + } + + public final Enable_triggerContext enable_trigger() throws RecognitionException { + Enable_triggerContext _localctx = new Enable_triggerContext(_ctx, getState()); + enterRule(_localctx, 454, RULE_enable_trigger); + try { + setState(4110); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,197,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4104); + match(ENABLE_P); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4105); + match(ENABLE_P); + setState(4106); + match(REPLICA); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4107); + match(ENABLE_P); + setState(4108); + match(ALWAYS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4109); + match(DISABLE_P); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateassertionstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode ASSERTION() { return getToken(PostgreSqlParser.ASSERTION, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ConstraintattributespecContext constraintattributespec() { + return getRuleContext(ConstraintattributespecContext.class,0); + } + public CreateassertionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createassertionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateassertionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateassertionstmt(this); + } + } + + public final CreateassertionstmtContext createassertionstmt() throws RecognitionException { + CreateassertionstmtContext _localctx = new CreateassertionstmtContext(_ctx, getState()); + enterRule(_localctx, 456, RULE_createassertionstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(4112); + match(CREATE); + setState(4113); + match(ASSERTION); + setState(4114); + any_name(); + setState(4115); + match(CHECK); + setState(4116); + match(OPEN_PAREN); + setState(4117); + a_expr(); + setState(4118); + match(CLOSE_PAREN); + setState(4119); + constraintattributespec(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DefinestmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public Opt_or_replaceContext opt_or_replace() { + return getRuleContext(Opt_or_replaceContext.class,0); + } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public Func_nameContext func_name() { + return getRuleContext(Func_nameContext.class,0); + } + public Aggr_argsContext aggr_args() { + return getRuleContext(Aggr_argsContext.class,0); + } + public DefinitionContext definition() { + return getRuleContext(DefinitionContext.class,0); + } + public Old_aggr_definitionContext old_aggr_definition() { + return getRuleContext(Old_aggr_definitionContext.class,0); + } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public Any_operatorContext any_operator() { + return getRuleContext(Any_operatorContext.class,0); + } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public List any_name() { + return getRuleContexts(Any_nameContext.class); + } + public Any_nameContext any_name(int i) { + return getRuleContext(Any_nameContext.class,i); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public OpttablefuncelementlistContext opttablefuncelementlist() { + return getRuleContext(OpttablefuncelementlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode ENUM_P() { return getToken(PostgreSqlParser.ENUM_P, 0); } + public Opt_enum_val_listContext opt_enum_val_list() { + return getRuleContext(Opt_enum_val_listContext.class,0); + } + public TerminalNode RANGE() { return getToken(PostgreSqlParser.RANGE, 0); } + public TerminalNode TEXT_P() { return getToken(PostgreSqlParser.TEXT_P, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode PARSER() { return getToken(PostgreSqlParser.PARSER, 0); } + public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } + public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } + public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } + public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public DefinestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_definestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDefinestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDefinestmt(this); + } + } + + public final DefinestmtContext definestmt() throws RecognitionException { + DefinestmtContext _localctx = new DefinestmtContext(_ctx, getState()); + enterRule(_localctx, 458, RULE_definestmt); + try { + setState(4227); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4121); + match(CREATE); + setState(4122); + opt_or_replace(); + setState(4123); + match(AGGREGATE); + setState(4124); + func_name(); + setState(4125); + aggr_args(); + setState(4126); + definition(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4128); + match(CREATE); + setState(4129); + opt_or_replace(); + setState(4130); + match(AGGREGATE); + setState(4131); + func_name(); + setState(4132); + old_aggr_definition(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4134); + match(CREATE); + setState(4135); + match(OPERATOR); + setState(4136); + any_operator(); + setState(4137); + definition(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4139); + match(CREATE); + setState(4140); + match(TYPE_P); + setState(4141); + any_name(); + setState(4142); + definition(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4144); + match(CREATE); + setState(4145); + match(TYPE_P); + setState(4146); + any_name(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(4147); + match(CREATE); + setState(4148); + match(TYPE_P); + setState(4149); + any_name(); + setState(4150); + match(AS); + setState(4151); + match(OPEN_PAREN); + setState(4152); + opttablefuncelementlist(); + setState(4153); + match(CLOSE_PAREN); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(4155); + match(CREATE); + setState(4156); + match(TYPE_P); + setState(4157); + any_name(); + setState(4158); + match(AS); + setState(4159); + match(ENUM_P); + setState(4160); + match(OPEN_PAREN); + setState(4161); + opt_enum_val_list(); + setState(4162); + match(CLOSE_PAREN); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(4164); + match(CREATE); + setState(4165); + match(TYPE_P); + setState(4166); + any_name(); + setState(4167); + match(AS); + setState(4168); + match(RANGE); + setState(4169); + definition(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(4171); + match(CREATE); + setState(4172); + match(TEXT_P); + setState(4173); + match(SEARCH); + setState(4174); + match(PARSER); + setState(4175); + any_name(); + setState(4176); + definition(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(4178); + match(CREATE); + setState(4179); + match(TEXT_P); + setState(4180); + match(SEARCH); + setState(4181); + match(DICTIONARY); + setState(4182); + any_name(); + setState(4183); + definition(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(4185); + match(CREATE); + setState(4186); + match(TEXT_P); + setState(4187); + match(SEARCH); + setState(4188); + match(TEMPLATE); + setState(4189); + any_name(); + setState(4190); + definition(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(4192); + match(CREATE); + setState(4193); + match(TEXT_P); + setState(4194); + match(SEARCH); + setState(4195); + match(CONFIGURATION); + setState(4196); + any_name(); + setState(4197); + definition(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(4199); + match(CREATE); + setState(4200); + match(COLLATION); + setState(4201); + any_name(); + setState(4202); + definition(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(4204); + match(CREATE); + setState(4205); + match(COLLATION); + setState(4206); + match(IF_P); + setState(4207); + match(NOT); + setState(4208); + match(EXISTS); + setState(4209); + any_name(); + setState(4210); + definition(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(4212); + match(CREATE); + setState(4213); + match(COLLATION); + setState(4214); + any_name(); + setState(4215); + match(FROM); + setState(4216); + any_name(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(4218); + match(CREATE); + setState(4219); + match(COLLATION); + setState(4220); + match(IF_P); + setState(4221); + match(NOT); + setState(4222); + match(EXISTS); + setState(4223); + any_name(); + setState(4224); + match(FROM); + setState(4225); + any_name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DefinitionContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Def_listContext def_list() { + return getRuleContext(Def_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public DefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDefinition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDefinition(this); + } + } + + public final DefinitionContext definition() throws RecognitionException { + DefinitionContext _localctx = new DefinitionContext(_ctx, getState()); + enterRule(_localctx, 460, RULE_definition); + try { + enterOuterAlt(_localctx, 1); + { + setState(4229); + match(OPEN_PAREN); + setState(4230); + def_list(); + setState(4231); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Def_listContext extends ParserRuleContext { + public List def_elem() { + return getRuleContexts(Def_elemContext.class); + } + public Def_elemContext def_elem(int i) { + return getRuleContext(Def_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Def_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_def_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDef_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDef_list(this); + } + } + + public final Def_listContext def_list() throws RecognitionException { + Def_listContext _localctx = new Def_listContext(_ctx, getState()); + enterRule(_localctx, 462, RULE_def_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4233); + def_elem(); + setState(4238); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4234); + match(COMMA); + setState(4235); + def_elem(); + } + } + setState(4240); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Def_elemContext extends ParserRuleContext { + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public Def_argContext def_arg() { + return getRuleContext(Def_argContext.class,0); + } + public Def_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_def_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDef_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDef_elem(this); + } + } + + public final Def_elemContext def_elem() throws RecognitionException { + Def_elemContext _localctx = new Def_elemContext(_ctx, getState()); + enterRule(_localctx, 464, RULE_def_elem); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4241); + collabel(); + setState(4244); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL) { + { + setState(4242); + match(EQUAL); + setState(4243); + def_arg(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Def_argContext extends ParserRuleContext { + public Func_typeContext func_type() { + return getRuleContext(Func_typeContext.class,0); + } + public Reserved_keywordContext reserved_keyword() { + return getRuleContext(Reserved_keywordContext.class,0); + } + public Qual_all_opContext qual_all_op() { + return getRuleContext(Qual_all_opContext.class,0); + } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode NONE() { return getToken(PostgreSqlParser.NONE, 0); } + public Def_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_def_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDef_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDef_arg(this); + } + } + + public final Def_argContext def_arg() throws RecognitionException { + Def_argContext _localctx = new Def_argContext(_ctx, getState()); + enterRule(_localctx, 466, RULE_def_arg); + try { + setState(4252); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4246); + func_type(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4247); + reserved_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4248); + qual_all_op(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4249); + numericonly(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4250); + sconst(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(4251); + match(NONE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Old_aggr_definitionContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Old_aggr_listContext old_aggr_list() { + return getRuleContext(Old_aggr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Old_aggr_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_old_aggr_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOld_aggr_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOld_aggr_definition(this); + } + } + + public final Old_aggr_definitionContext old_aggr_definition() throws RecognitionException { + Old_aggr_definitionContext _localctx = new Old_aggr_definitionContext(_ctx, getState()); + enterRule(_localctx, 468, RULE_old_aggr_definition); + try { + enterOuterAlt(_localctx, 1); + { + setState(4254); + match(OPEN_PAREN); + setState(4255); + old_aggr_list(); + setState(4256); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Old_aggr_listContext extends ParserRuleContext { + public List old_aggr_elem() { + return getRuleContexts(Old_aggr_elemContext.class); + } + public Old_aggr_elemContext old_aggr_elem(int i) { + return getRuleContext(Old_aggr_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Old_aggr_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_old_aggr_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOld_aggr_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOld_aggr_list(this); + } + } + + public final Old_aggr_listContext old_aggr_list() throws RecognitionException { + Old_aggr_listContext _localctx = new Old_aggr_listContext(_ctx, getState()); + enterRule(_localctx, 470, RULE_old_aggr_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4258); + old_aggr_elem(); + setState(4263); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4259); + match(COMMA); + setState(4260); + old_aggr_elem(); + } + } + setState(4265); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Old_aggr_elemContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public Def_argContext def_arg() { + return getRuleContext(Def_argContext.class,0); + } + public Old_aggr_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_old_aggr_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOld_aggr_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOld_aggr_elem(this); + } + } + + public final Old_aggr_elemContext old_aggr_elem() throws RecognitionException { + Old_aggr_elemContext _localctx = new Old_aggr_elemContext(_ctx, getState()); + enterRule(_localctx, 472, RULE_old_aggr_elem); + try { + enterOuterAlt(_localctx, 1); + { + setState(4266); + identifier(); + setState(4267); + match(EQUAL); + setState(4268); + def_arg(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_enum_val_listContext extends ParserRuleContext { + public Enum_val_listContext enum_val_list() { + return getRuleContext(Enum_val_listContext.class,0); + } + public Opt_enum_val_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_enum_val_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_enum_val_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_enum_val_list(this); + } + } + + public final Opt_enum_val_listContext opt_enum_val_list() throws RecognitionException { + Opt_enum_val_listContext _localctx = new Opt_enum_val_listContext(_ctx, getState()); + enterRule(_localctx, 474, RULE_opt_enum_val_list); + try { + setState(4272); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(4270); + enum_val_list(); + } + break; + case CLOSE_PAREN: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Enum_val_listContext extends ParserRuleContext { + public List sconst() { + return getRuleContexts(SconstContext.class); + } + public SconstContext sconst(int i) { + return getRuleContext(SconstContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Enum_val_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enum_val_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterEnum_val_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitEnum_val_list(this); + } + } + + public final Enum_val_listContext enum_val_list() throws RecognitionException { + Enum_val_listContext _localctx = new Enum_val_listContext(_ctx, getState()); + enterRule(_localctx, 476, RULE_enum_val_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4274); + sconst(); + setState(4279); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4275); + match(COMMA); + setState(4276); + sconst(); + } + } + setState(4281); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterenumstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public TerminalNode VALUE_P() { return getToken(PostgreSqlParser.VALUE_P, 0); } + public Opt_if_not_existsContext opt_if_not_exists() { + return getRuleContext(Opt_if_not_existsContext.class,0); + } + public List sconst() { + return getRuleContexts(SconstContext.class); + } + public SconstContext sconst(int i) { + return getRuleContext(SconstContext.class,i); + } + public TerminalNode BEFORE() { return getToken(PostgreSqlParser.BEFORE, 0); } + public TerminalNode AFTER() { return getToken(PostgreSqlParser.AFTER, 0); } + public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public AlterenumstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterenumstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterenumstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterenumstmt(this); + } + } + + public final AlterenumstmtContext alterenumstmt() throws RecognitionException { + AlterenumstmtContext _localctx = new AlterenumstmtContext(_ctx, getState()); + enterRule(_localctx, 478, RULE_alterenumstmt); + try { + setState(4319); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4282); + match(ALTER); + setState(4283); + match(TYPE_P); + setState(4284); + any_name(); + setState(4285); + match(ADD_P); + setState(4286); + match(VALUE_P); + setState(4287); + opt_if_not_exists(); + setState(4288); + sconst(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4290); + match(ALTER); + setState(4291); + match(TYPE_P); + setState(4292); + any_name(); + setState(4293); + match(ADD_P); + setState(4294); + match(VALUE_P); + setState(4295); + opt_if_not_exists(); + setState(4296); + sconst(); + setState(4297); + match(BEFORE); + setState(4298); + sconst(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4300); + match(ALTER); + setState(4301); + match(TYPE_P); + setState(4302); + any_name(); + setState(4303); + match(ADD_P); + setState(4304); + match(VALUE_P); + setState(4305); + opt_if_not_exists(); + setState(4306); + sconst(); + setState(4307); + match(AFTER); + setState(4308); + sconst(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4310); + match(ALTER); + setState(4311); + match(TYPE_P); + setState(4312); + any_name(); + setState(4313); + match(RENAME); + setState(4314); + match(VALUE_P); + setState(4315); + sconst(); + setState(4316); + match(TO); + setState(4317); + sconst(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_if_not_existsContext extends ParserRuleContext { + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public Opt_if_not_existsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_if_not_exists; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_if_not_exists(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_if_not_exists(this); + } + } + + public final Opt_if_not_existsContext opt_if_not_exists() throws RecognitionException { + Opt_if_not_existsContext _localctx = new Opt_if_not_existsContext(_ctx, getState()); + enterRule(_localctx, 480, RULE_opt_if_not_exists); + try { + setState(4325); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IF_P: + enterOuterAlt(_localctx, 1); + { + setState(4321); + match(IF_P); + setState(4322); + match(NOT); + setState(4323); + match(EXISTS); + } + break; + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateopclassstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Opt_defaultContext opt_default() { + return getRuleContext(Opt_defaultContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_opfamilyContext opt_opfamily() { + return getRuleContext(Opt_opfamilyContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public Opclass_item_listContext opclass_item_list() { + return getRuleContext(Opclass_item_listContext.class,0); + } + public CreateopclassstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createopclassstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateopclassstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateopclassstmt(this); + } + } + + public final CreateopclassstmtContext createopclassstmt() throws RecognitionException { + CreateopclassstmtContext _localctx = new CreateopclassstmtContext(_ctx, getState()); + enterRule(_localctx, 482, RULE_createopclassstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(4327); + match(CREATE); + setState(4328); + match(OPERATOR); + setState(4329); + match(CLASS); + setState(4330); + any_name(); + setState(4331); + opt_default(); + setState(4332); + match(FOR); + setState(4333); + match(TYPE_P); + setState(4334); + typename(); + setState(4335); + match(USING); + setState(4336); + name(); + setState(4337); + opt_opfamily(); + setState(4338); + match(AS); + setState(4339); + opclass_item_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opclass_item_listContext extends ParserRuleContext { + public List opclass_item() { + return getRuleContexts(Opclass_itemContext.class); + } + public Opclass_itemContext opclass_item(int i) { + return getRuleContext(Opclass_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Opclass_item_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opclass_item_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpclass_item_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpclass_item_list(this); + } + } + + public final Opclass_item_listContext opclass_item_list() throws RecognitionException { + Opclass_item_listContext _localctx = new Opclass_item_listContext(_ctx, getState()); + enterRule(_localctx, 484, RULE_opclass_item_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4341); + opclass_item(); + setState(4346); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4342); + match(COMMA); + setState(4343); + opclass_item(); + } + } + setState(4348); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opclass_itemContext extends ParserRuleContext { + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public Any_operatorContext any_operator() { + return getRuleContext(Any_operatorContext.class,0); + } + public Opclass_purposeContext opclass_purpose() { + return getRuleContext(Opclass_purposeContext.class,0); + } + public Opt_recheckContext opt_recheck() { + return getRuleContext(Opt_recheckContext.class,0); + } + public Operator_with_argtypesContext operator_with_argtypes() { + return getRuleContext(Operator_with_argtypesContext.class,0); + } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Type_listContext type_list() { + return getRuleContext(Type_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode STORAGE() { return getToken(PostgreSqlParser.STORAGE, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public Opclass_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opclass_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpclass_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpclass_item(this); + } + } + + public final Opclass_itemContext opclass_item() throws RecognitionException { + Opclass_itemContext _localctx = new Opclass_itemContext(_ctx, getState()); + enterRule(_localctx, 486, RULE_opclass_item); + try { + setState(4374); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4349); + match(OPERATOR); + setState(4350); + iconst(); + setState(4351); + any_operator(); + setState(4352); + opclass_purpose(); + setState(4353); + opt_recheck(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4355); + match(OPERATOR); + setState(4356); + iconst(); + setState(4357); + operator_with_argtypes(); + setState(4358); + opclass_purpose(); + setState(4359); + opt_recheck(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4361); + match(FUNCTION); + setState(4362); + iconst(); + setState(4363); + function_with_argtypes(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4365); + match(FUNCTION); + setState(4366); + iconst(); + setState(4367); + match(OPEN_PAREN); + setState(4368); + type_list(); + setState(4369); + match(CLOSE_PAREN); + setState(4370); + function_with_argtypes(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4372); + match(STORAGE); + setState(4373); + typename(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_defaultContext extends ParserRuleContext { + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public Opt_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_default; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_default(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_default(this); + } + } + + public final Opt_defaultContext opt_default() throws RecognitionException { + Opt_defaultContext _localctx = new Opt_defaultContext(_ctx, getState()); + enterRule(_localctx, 488, RULE_opt_default); + try { + setState(4378); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEFAULT: + enterOuterAlt(_localctx, 1); + { + setState(4376); + match(DEFAULT); + } + break; + case FOR: + case CONVERSION_P: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_opfamilyContext extends ParserRuleContext { + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Opt_opfamilyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_opfamily; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_opfamily(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_opfamily(this); + } + } + + public final Opt_opfamilyContext opt_opfamily() throws RecognitionException { + Opt_opfamilyContext _localctx = new Opt_opfamilyContext(_ctx, getState()); + enterRule(_localctx, 490, RULE_opt_opfamily); + try { + setState(4383); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FAMILY: + enterOuterAlt(_localctx, 1); + { + setState(4380); + match(FAMILY); + setState(4381); + any_name(); + } + break; + case AS: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opclass_purposeContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode ORDER() { return getToken(PostgreSqlParser.ORDER, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Opclass_purposeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opclass_purpose; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpclass_purpose(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpclass_purpose(this); + } + } + + public final Opclass_purposeContext opclass_purpose() throws RecognitionException { + Opclass_purposeContext _localctx = new Opclass_purposeContext(_ctx, getState()); + enterRule(_localctx, 492, RULE_opclass_purpose); + try { + setState(4392); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4385); + match(FOR); + setState(4386); + match(SEARCH); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4387); + match(FOR); + setState(4388); + match(ORDER); + setState(4389); + match(BY); + setState(4390); + any_name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_recheckContext extends ParserRuleContext { + public TerminalNode RECHECK() { return getToken(PostgreSqlParser.RECHECK, 0); } + public Opt_recheckContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_recheck; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_recheck(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_recheck(this); + } + } + + public final Opt_recheckContext opt_recheck() throws RecognitionException { + Opt_recheckContext _localctx = new Opt_recheckContext(_ctx, getState()); + enterRule(_localctx, 494, RULE_opt_recheck); + try { + setState(4396); + _errHandler.sync(this); + switch (_input.LA(1)) { + case RECHECK: + enterOuterAlt(_localctx, 1); + { + setState(4394); + match(RECHECK); + } + break; + case EOF: + case OPEN_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateopfamilystmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public CreateopfamilystmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createopfamilystmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateopfamilystmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateopfamilystmt(this); + } + } + + public final CreateopfamilystmtContext createopfamilystmt() throws RecognitionException { + CreateopfamilystmtContext _localctx = new CreateopfamilystmtContext(_ctx, getState()); + enterRule(_localctx, 496, RULE_createopfamilystmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(4398); + match(CREATE); + setState(4399); + match(OPERATOR); + setState(4400); + match(FAMILY); + setState(4401); + any_name(); + setState(4402); + match(USING); + setState(4403); + name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlteropfamilystmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public Opclass_item_listContext opclass_item_list() { + return getRuleContext(Opclass_item_listContext.class,0); + } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public Opclass_drop_listContext opclass_drop_list() { + return getRuleContext(Opclass_drop_listContext.class,0); + } + public AlteropfamilystmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alteropfamilystmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlteropfamilystmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlteropfamilystmt(this); + } + } + + public final AlteropfamilystmtContext alteropfamilystmt() throws RecognitionException { + AlteropfamilystmtContext _localctx = new AlteropfamilystmtContext(_ctx, getState()); + enterRule(_localctx, 498, RULE_alteropfamilystmt); + try { + setState(4423); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4405); + match(ALTER); + setState(4406); + match(OPERATOR); + setState(4407); + match(FAMILY); + setState(4408); + any_name(); + setState(4409); + match(USING); + setState(4410); + name(); + setState(4411); + match(ADD_P); + setState(4412); + opclass_item_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4414); + match(ALTER); + setState(4415); + match(OPERATOR); + setState(4416); + match(FAMILY); + setState(4417); + any_name(); + setState(4418); + match(USING); + setState(4419); + name(); + setState(4420); + match(DROP); + setState(4421); + opclass_drop_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opclass_drop_listContext extends ParserRuleContext { + public List opclass_drop() { + return getRuleContexts(Opclass_dropContext.class); + } + public Opclass_dropContext opclass_drop(int i) { + return getRuleContext(Opclass_dropContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Opclass_drop_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opclass_drop_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpclass_drop_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpclass_drop_list(this); + } + } + + public final Opclass_drop_listContext opclass_drop_list() throws RecognitionException { + Opclass_drop_listContext _localctx = new Opclass_drop_listContext(_ctx, getState()); + enterRule(_localctx, 500, RULE_opclass_drop_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4425); + opclass_drop(); + setState(4430); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4426); + match(COMMA); + setState(4427); + opclass_drop(); + } + } + setState(4432); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opclass_dropContext extends ParserRuleContext { + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Type_listContext type_list() { + return getRuleContext(Type_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Opclass_dropContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opclass_drop; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpclass_drop(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpclass_drop(this); + } + } + + public final Opclass_dropContext opclass_drop() throws RecognitionException { + Opclass_dropContext _localctx = new Opclass_dropContext(_ctx, getState()); + enterRule(_localctx, 502, RULE_opclass_drop); + try { + setState(4445); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPERATOR: + enterOuterAlt(_localctx, 1); + { + setState(4433); + match(OPERATOR); + setState(4434); + iconst(); + setState(4435); + match(OPEN_PAREN); + setState(4436); + type_list(); + setState(4437); + match(CLOSE_PAREN); + } + break; + case FUNCTION: + enterOuterAlt(_localctx, 2); + { + setState(4439); + match(FUNCTION); + setState(4440); + iconst(); + setState(4441); + match(OPEN_PAREN); + setState(4442); + type_list(); + setState(4443); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropopclassstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public DropopclassstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropopclassstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDropopclassstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDropopclassstmt(this); + } + } + + public final DropopclassstmtContext dropopclassstmt() throws RecognitionException { + DropopclassstmtContext _localctx = new DropopclassstmtContext(_ctx, getState()); + enterRule(_localctx, 504, RULE_dropopclassstmt); + try { + setState(4465); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4447); + match(DROP); + setState(4448); + match(OPERATOR); + setState(4449); + match(CLASS); + setState(4450); + any_name(); + setState(4451); + match(USING); + setState(4452); + name(); + setState(4453); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4455); + match(DROP); + setState(4456); + match(OPERATOR); + setState(4457); + match(CLASS); + setState(4458); + match(IF_P); + setState(4459); + match(EXISTS); + setState(4460); + any_name(); + setState(4461); + match(USING); + setState(4462); + name(); + setState(4463); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropopfamilystmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public DropopfamilystmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropopfamilystmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDropopfamilystmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDropopfamilystmt(this); + } + } + + public final DropopfamilystmtContext dropopfamilystmt() throws RecognitionException { + DropopfamilystmtContext _localctx = new DropopfamilystmtContext(_ctx, getState()); + enterRule(_localctx, 506, RULE_dropopfamilystmt); + try { + setState(4485); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,217,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4467); + match(DROP); + setState(4468); + match(OPERATOR); + setState(4469); + match(FAMILY); + setState(4470); + any_name(); + setState(4471); + match(USING); + setState(4472); + name(); + setState(4473); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4475); + match(DROP); + setState(4476); + match(OPERATOR); + setState(4477); + match(FAMILY); + setState(4478); + match(IF_P); + setState(4479); + match(EXISTS); + setState(4480); + any_name(); + setState(4481); + match(USING); + setState(4482); + name(); + setState(4483); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropownedstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public DropownedstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropownedstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDropownedstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDropownedstmt(this); + } + } + + public final DropownedstmtContext dropownedstmt() throws RecognitionException { + DropownedstmtContext _localctx = new DropownedstmtContext(_ctx, getState()); + enterRule(_localctx, 508, RULE_dropownedstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(4487); + match(DROP); + setState(4488); + match(OWNED); + setState(4489); + match(BY); + setState(4490); + role_list(); + setState(4491); + opt_drop_behavior(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReassignownedstmtContext extends ParserRuleContext { + public TerminalNode REASSIGN() { return getToken(PostgreSqlParser.REASSIGN, 0); } + public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public ReassignownedstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reassignownedstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReassignownedstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReassignownedstmt(this); + } + } + + public final ReassignownedstmtContext reassignownedstmt() throws RecognitionException { + ReassignownedstmtContext _localctx = new ReassignownedstmtContext(_ctx, getState()); + enterRule(_localctx, 510, RULE_reassignownedstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(4493); + match(REASSIGN); + setState(4494); + match(OWNED); + setState(4495); + match(BY); + setState(4496); + role_list(); + setState(4497); + match(TO); + setState(4498); + rolespec(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public Object_type_any_nameContext object_type_any_name() { + return getRuleContext(Object_type_any_nameContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public Any_name_listContext any_name_list() { + return getRuleContext(Any_name_listContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public Drop_type_nameContext drop_type_name() { + return getRuleContext(Drop_type_nameContext.class,0); + } + public Name_listContext name_list() { + return getRuleContext(Name_listContext.class,0); + } + public Object_type_name_on_any_nameContext object_type_name_on_any_name() { + return getRuleContext(Object_type_name_on_any_nameContext.class,0); + } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public Type_name_listContext type_name_list() { + return getRuleContext(Type_name_listContext.class,0); + } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public TerminalNode CONCURRENTLY() { return getToken(PostgreSqlParser.CONCURRENTLY, 0); } + public DropstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDropstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDropstmt(this); + } + } + + public final DropstmtContext dropstmt() throws RecognitionException { + DropstmtContext _localctx = new DropstmtContext(_ctx, getState()); + enterRule(_localctx, 512, RULE_dropstmt); + try { + setState(4578); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4500); + match(DROP); + setState(4501); + object_type_any_name(); + setState(4502); + match(IF_P); + setState(4503); + match(EXISTS); + setState(4504); + any_name_list(); + setState(4505); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4507); + match(DROP); + setState(4508); + object_type_any_name(); + setState(4509); + any_name_list(); + setState(4510); + opt_drop_behavior(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4512); + match(DROP); + setState(4513); + drop_type_name(); + setState(4514); + match(IF_P); + setState(4515); + match(EXISTS); + setState(4516); + name_list(); + setState(4517); + opt_drop_behavior(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4519); + match(DROP); + setState(4520); + drop_type_name(); + setState(4521); + name_list(); + setState(4522); + opt_drop_behavior(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4524); + match(DROP); + setState(4525); + object_type_name_on_any_name(); + setState(4526); + name(); + setState(4527); + match(ON); + setState(4528); + any_name(); + setState(4529); + opt_drop_behavior(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(4531); + match(DROP); + setState(4532); + object_type_name_on_any_name(); + setState(4533); + match(IF_P); + setState(4534); + match(EXISTS); + setState(4535); + name(); + setState(4536); + match(ON); + setState(4537); + any_name(); + setState(4538); + opt_drop_behavior(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(4540); + match(DROP); + setState(4541); + match(TYPE_P); + setState(4542); + type_name_list(); + setState(4543); + opt_drop_behavior(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(4545); + match(DROP); + setState(4546); + match(TYPE_P); + setState(4547); + match(IF_P); + setState(4548); + match(EXISTS); + setState(4549); + type_name_list(); + setState(4550); + opt_drop_behavior(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(4552); + match(DROP); + setState(4553); + match(DOMAIN_P); + setState(4554); + type_name_list(); + setState(4555); + opt_drop_behavior(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(4557); + match(DROP); + setState(4558); + match(DOMAIN_P); + setState(4559); + match(IF_P); + setState(4560); + match(EXISTS); + setState(4561); + type_name_list(); + setState(4562); + opt_drop_behavior(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(4564); + match(DROP); + setState(4565); + match(INDEX); + setState(4566); + match(CONCURRENTLY); + setState(4567); + any_name_list(); + setState(4568); + opt_drop_behavior(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(4570); + match(DROP); + setState(4571); + match(INDEX); + setState(4572); + match(CONCURRENTLY); + setState(4573); + match(IF_P); + setState(4574); + match(EXISTS); + setState(4575); + any_name_list(); + setState(4576); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Object_type_any_nameContext extends ParserRuleContext { + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } + public TerminalNode CONVERSION_P() { return getToken(PostgreSqlParser.CONVERSION_P, 0); } + public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } + public TerminalNode TEXT_P() { return getToken(PostgreSqlParser.TEXT_P, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode PARSER() { return getToken(PostgreSqlParser.PARSER, 0); } + public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } + public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } + public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } + public Object_type_any_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_object_type_any_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterObject_type_any_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitObject_type_any_name(this); + } + } + + public final Object_type_any_nameContext object_type_any_name() throws RecognitionException { + Object_type_any_nameContext _localctx = new Object_type_any_nameContext(_ctx, getState()); + enterRule(_localctx, 514, RULE_object_type_any_name); + try { + setState(4603); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4580); + match(TABLE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4581); + match(SEQUENCE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4582); + match(VIEW); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4583); + match(MATERIALIZED); + setState(4584); + match(VIEW); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4585); + match(INDEX); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(4586); + match(FOREIGN); + setState(4587); + match(TABLE); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(4588); + match(COLLATION); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(4589); + match(CONVERSION_P); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(4590); + match(STATISTICS); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(4591); + match(TEXT_P); + setState(4592); + match(SEARCH); + setState(4593); + match(PARSER); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(4594); + match(TEXT_P); + setState(4595); + match(SEARCH); + setState(4596); + match(DICTIONARY); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(4597); + match(TEXT_P); + setState(4598); + match(SEARCH); + setState(4599); + match(TEMPLATE); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(4600); + match(TEXT_P); + setState(4601); + match(SEARCH); + setState(4602); + match(CONFIGURATION); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Object_type_nameContext extends ParserRuleContext { + public Drop_type_nameContext drop_type_name() { + return getRuleContext(Drop_type_nameContext.class,0); + } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public Object_type_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_object_type_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterObject_type_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitObject_type_name(this); + } + } + + public final Object_type_nameContext object_type_name() throws RecognitionException { + Object_type_nameContext _localctx = new Object_type_nameContext(_ctx, getState()); + enterRule(_localctx, 516, RULE_object_type_name); + try { + setState(4610); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOREIGN: + case ACCESS: + case EVENT: + case EXTENSION: + case LANGUAGE: + case PROCEDURAL: + case SCHEMA: + case SERVER: + case PUBLICATION: + enterOuterAlt(_localctx, 1); + { + setState(4605); + drop_type_name(); + } + break; + case DATABASE: + enterOuterAlt(_localctx, 2); + { + setState(4606); + match(DATABASE); + } + break; + case ROLE: + enterOuterAlt(_localctx, 3); + { + setState(4607); + match(ROLE); + } + break; + case SUBSCRIPTION: + enterOuterAlt(_localctx, 4); + { + setState(4608); + match(SUBSCRIPTION); + } + break; + case TABLESPACE: + enterOuterAlt(_localctx, 5); + { + setState(4609); + match(TABLESPACE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Drop_type_nameContext extends ParserRuleContext { + public TerminalNode ACCESS() { return getToken(PostgreSqlParser.ACCESS, 0); } + public TerminalNode METHOD() { return getToken(PostgreSqlParser.METHOD, 0); } + public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } + public Opt_proceduralContext opt_procedural() { + return getRuleContext(Opt_proceduralContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public Drop_type_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_drop_type_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_type_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_type_name(this); + } + } + + public final Drop_type_nameContext drop_type_name() throws RecognitionException { + Drop_type_nameContext _localctx = new Drop_type_nameContext(_ctx, getState()); + enterRule(_localctx, 518, RULE_drop_type_name); + try { + setState(4626); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ACCESS: + enterOuterAlt(_localctx, 1); + { + setState(4612); + match(ACCESS); + setState(4613); + match(METHOD); + } + break; + case EVENT: + enterOuterAlt(_localctx, 2); + { + setState(4614); + match(EVENT); + setState(4615); + match(TRIGGER); + } + break; + case EXTENSION: + enterOuterAlt(_localctx, 3); + { + setState(4616); + match(EXTENSION); + } + break; + case FOREIGN: + enterOuterAlt(_localctx, 4); + { + setState(4617); + match(FOREIGN); + setState(4618); + match(DATA_P); + setState(4619); + match(WRAPPER); + } + break; + case LANGUAGE: + case PROCEDURAL: + enterOuterAlt(_localctx, 5); + { + setState(4620); + opt_procedural(); + setState(4621); + match(LANGUAGE); + } + break; + case PUBLICATION: + enterOuterAlt(_localctx, 6); + { + setState(4623); + match(PUBLICATION); + } + break; + case SCHEMA: + enterOuterAlt(_localctx, 7); + { + setState(4624); + match(SCHEMA); + } + break; + case SERVER: + enterOuterAlt(_localctx, 8); + { + setState(4625); + match(SERVER); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Object_type_name_on_any_nameContext extends ParserRuleContext { + public TerminalNode POLICY() { return getToken(PostgreSqlParser.POLICY, 0); } + public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public Object_type_name_on_any_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_object_type_name_on_any_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterObject_type_name_on_any_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitObject_type_name_on_any_name(this); + } + } + + public final Object_type_name_on_any_nameContext object_type_name_on_any_name() throws RecognitionException { + Object_type_name_on_any_nameContext _localctx = new Object_type_name_on_any_nameContext(_ctx, getState()); + enterRule(_localctx, 520, RULE_object_type_name_on_any_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4628); + _la = _input.LA(1); + if ( !(_la==RULE || _la==TRIGGER || _la==POLICY) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Any_name_listContext extends ParserRuleContext { + public List any_name() { + return getRuleContexts(Any_nameContext.class); + } + public Any_nameContext any_name(int i) { + return getRuleContext(Any_nameContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Any_name_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_any_name_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAny_name_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAny_name_list(this); + } + } + + public final Any_name_listContext any_name_list() throws RecognitionException { + Any_name_listContext _localctx = new Any_name_listContext(_ctx, getState()); + enterRule(_localctx, 522, RULE_any_name_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4630); + any_name(); + setState(4635); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4631); + match(COMMA); + setState(4632); + any_name(); + } + } + setState(4637); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Any_nameContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public AttrsContext attrs() { + return getRuleContext(AttrsContext.class,0); + } + public Any_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_any_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAny_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAny_name(this); + } + } + + public final Any_nameContext any_name() throws RecognitionException { + Any_nameContext _localctx = new Any_nameContext(_ctx, getState()); + enterRule(_localctx, 524, RULE_any_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4638); + colid(); + setState(4640); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DOT) { + { + setState(4639); + attrs(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AttrsContext extends ParserRuleContext { + public List DOT() { return getTokens(PostgreSqlParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(PostgreSqlParser.DOT, i); + } + public List attr_name() { + return getRuleContexts(Attr_nameContext.class); + } + public Attr_nameContext attr_name(int i) { + return getRuleContext(Attr_nameContext.class,i); + } + public AttrsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attrs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAttrs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAttrs(this); + } + } + + public final AttrsContext attrs() throws RecognitionException { + AttrsContext _localctx = new AttrsContext(_ctx, getState()); + enterRule(_localctx, 526, RULE_attrs); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4644); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4642); + match(DOT); + setState(4643); + attr_name(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4646); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,224,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_name_listContext extends ParserRuleContext { + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Type_name_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_name_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterType_name_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitType_name_list(this); + } + } + + public final Type_name_listContext type_name_list() throws RecognitionException { + Type_name_listContext _localctx = new Type_name_listContext(_ctx, getState()); + enterRule(_localctx, 528, RULE_type_name_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4648); + typename(); + setState(4653); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4649); + match(COMMA); + setState(4650); + typename(); + } + } + setState(4655); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TruncatestmtContext extends ParserRuleContext { + public TerminalNode TRUNCATE() { return getToken(PostgreSqlParser.TRUNCATE, 0); } + public Opt_tableContext opt_table() { + return getRuleContext(Opt_tableContext.class,0); + } + public Relation_expr_listContext relation_expr_list() { + return getRuleContext(Relation_expr_listContext.class,0); + } + public Opt_restart_seqsContext opt_restart_seqs() { + return getRuleContext(Opt_restart_seqsContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TruncatestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_truncatestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTruncatestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTruncatestmt(this); + } + } + + public final TruncatestmtContext truncatestmt() throws RecognitionException { + TruncatestmtContext _localctx = new TruncatestmtContext(_ctx, getState()); + enterRule(_localctx, 530, RULE_truncatestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(4656); + match(TRUNCATE); + setState(4657); + opt_table(); + setState(4658); + relation_expr_list(); + setState(4659); + opt_restart_seqs(); + setState(4660); + opt_drop_behavior(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_restart_seqsContext extends ParserRuleContext { + public TerminalNode CONTINUE_P() { return getToken(PostgreSqlParser.CONTINUE_P, 0); } + public TerminalNode IDENTITY_P() { return getToken(PostgreSqlParser.IDENTITY_P, 0); } + public TerminalNode RESTART() { return getToken(PostgreSqlParser.RESTART, 0); } + public Opt_restart_seqsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_restart_seqs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_restart_seqs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_restart_seqs(this); + } + } + + public final Opt_restart_seqsContext opt_restart_seqs() throws RecognitionException { + Opt_restart_seqsContext _localctx = new Opt_restart_seqsContext(_ctx, getState()); + enterRule(_localctx, 532, RULE_opt_restart_seqs); + try { + setState(4667); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CONTINUE_P: + enterOuterAlt(_localctx, 1); + { + setState(4662); + match(CONTINUE_P); + setState(4663); + match(IDENTITY_P); + } + break; + case RESTART: + enterOuterAlt(_localctx, 2); + { + setState(4664); + match(RESTART); + setState(4665); + match(IDENTITY_P); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CASCADE: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case RESTRICT: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CommentstmtContext extends ParserRuleContext { + public TerminalNode COMMENT() { return getToken(PostgreSqlParser.COMMENT, 0); } + public List ON() { return getTokens(PostgreSqlParser.ON); } + public TerminalNode ON(int i) { + return getToken(PostgreSqlParser.ON, i); + } + public Object_type_any_nameContext object_type_any_name() { + return getRuleContext(Object_type_any_nameContext.class,0); + } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } + public Comment_textContext comment_text() { + return getRuleContext(Comment_textContext.class,0); + } + public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } + public Object_type_nameContext object_type_name() { + return getRuleContext(Object_type_nameContext.class,0); + } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public Aggregate_with_argtypesContext aggregate_with_argtypes() { + return getRuleContext(Aggregate_with_argtypesContext.class,0); + } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public Operator_with_argtypesContext operator_with_argtypes() { + return getRuleContext(Operator_with_argtypesContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public Object_type_name_on_any_nameContext object_type_name_on_any_name() { + return getRuleContext(Object_type_name_on_any_nameContext.class,0); + } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public TerminalNode TRANSFORM() { return getToken(PostgreSqlParser.TRANSFORM, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public TerminalNode LARGE_P() { return getToken(PostgreSqlParser.LARGE_P, 0); } + public TerminalNode OBJECT_P() { return getToken(PostgreSqlParser.OBJECT_P, 0); } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public CommentstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_commentstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCommentstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCommentstmt(this); + } + } + + public final CommentstmtContext commentstmt() throws RecognitionException { + CommentstmtContext _localctx = new CommentstmtContext(_ctx, getState()); + enterRule(_localctx, 534, RULE_commentstmt); + try { + setState(4816); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4669); + match(COMMENT); + setState(4670); + match(ON); + setState(4671); + object_type_any_name(); + setState(4672); + any_name(); + setState(4673); + match(IS); + setState(4674); + comment_text(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4676); + match(COMMENT); + setState(4677); + match(ON); + setState(4678); + match(COLUMN); + setState(4679); + any_name(); + setState(4680); + match(IS); + setState(4681); + comment_text(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4683); + match(COMMENT); + setState(4684); + match(ON); + setState(4685); + object_type_name(); + setState(4686); + name(); + setState(4687); + match(IS); + setState(4688); + comment_text(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4690); + match(COMMENT); + setState(4691); + match(ON); + setState(4692); + match(TYPE_P); + setState(4693); + typename(); + setState(4694); + match(IS); + setState(4695); + comment_text(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4697); + match(COMMENT); + setState(4698); + match(ON); + setState(4699); + match(DOMAIN_P); + setState(4700); + typename(); + setState(4701); + match(IS); + setState(4702); + comment_text(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(4704); + match(COMMENT); + setState(4705); + match(ON); + setState(4706); + match(AGGREGATE); + setState(4707); + aggregate_with_argtypes(); + setState(4708); + match(IS); + setState(4709); + comment_text(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(4711); + match(COMMENT); + setState(4712); + match(ON); + setState(4713); + match(FUNCTION); + setState(4714); + function_with_argtypes(); + setState(4715); + match(IS); + setState(4716); + comment_text(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(4718); + match(COMMENT); + setState(4719); + match(ON); + setState(4720); + match(OPERATOR); + setState(4721); + operator_with_argtypes(); + setState(4722); + match(IS); + setState(4723); + comment_text(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(4725); + match(COMMENT); + setState(4726); + match(ON); + setState(4727); + match(CONSTRAINT); + setState(4728); + name(); + setState(4729); + match(ON); + setState(4730); + any_name(); + setState(4731); + match(IS); + setState(4732); + comment_text(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(4734); + match(COMMENT); + setState(4735); + match(ON); + setState(4736); + match(CONSTRAINT); + setState(4737); + name(); + setState(4738); + match(ON); + setState(4739); + match(DOMAIN_P); + setState(4740); + any_name(); + setState(4741); + match(IS); + setState(4742); + comment_text(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(4744); + match(COMMENT); + setState(4745); + match(ON); + setState(4746); + object_type_name_on_any_name(); + setState(4747); + name(); + setState(4748); + match(ON); + setState(4749); + any_name(); + setState(4750); + match(IS); + setState(4751); + comment_text(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(4753); + match(COMMENT); + setState(4754); + match(ON); + setState(4755); + match(PROCEDURE); + setState(4756); + function_with_argtypes(); + setState(4757); + match(IS); + setState(4758); + comment_text(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(4760); + match(COMMENT); + setState(4761); + match(ON); + setState(4762); + match(ROUTINE); + setState(4763); + function_with_argtypes(); + setState(4764); + match(IS); + setState(4765); + comment_text(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(4767); + match(COMMENT); + setState(4768); + match(ON); + setState(4769); + match(TRANSFORM); + setState(4770); + match(FOR); + setState(4771); + typename(); + setState(4772); + match(LANGUAGE); + setState(4773); + name(); + setState(4774); + match(IS); + setState(4775); + comment_text(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(4777); + match(COMMENT); + setState(4778); + match(ON); + setState(4779); + match(OPERATOR); + setState(4780); + match(CLASS); + setState(4781); + any_name(); + setState(4782); + match(USING); + setState(4783); + name(); + setState(4784); + match(IS); + setState(4785); + comment_text(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(4787); + match(COMMENT); + setState(4788); + match(ON); + setState(4789); + match(OPERATOR); + setState(4790); + match(FAMILY); + setState(4791); + any_name(); + setState(4792); + match(USING); + setState(4793); + name(); + setState(4794); + match(IS); + setState(4795); + comment_text(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(4797); + match(COMMENT); + setState(4798); + match(ON); + setState(4799); + match(LARGE_P); + setState(4800); + match(OBJECT_P); + setState(4801); + numericonly(); + setState(4802); + match(IS); + setState(4803); + comment_text(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(4805); + match(COMMENT); + setState(4806); + match(ON); + setState(4807); + match(CAST); + setState(4808); + match(OPEN_PAREN); + setState(4809); + typename(); + setState(4810); + match(AS); + setState(4811); + typename(); + setState(4812); + match(CLOSE_PAREN); + setState(4813); + match(IS); + setState(4814); + comment_text(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Comment_textContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public Comment_textContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comment_text; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterComment_text(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitComment_text(this); + } + } + + public final Comment_textContext comment_text() throws RecognitionException { + Comment_textContext _localctx = new Comment_textContext(_ctx, getState()); + enterRule(_localctx, 536, RULE_comment_text); + try { + setState(4820); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(4818); + sconst(); + } + break; + case NULL_P: + enterOuterAlt(_localctx, 2); + { + setState(4819); + match(NULL_P); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SeclabelstmtContext extends ParserRuleContext { + public TerminalNode SECURITY() { return getToken(PostgreSqlParser.SECURITY, 0); } + public TerminalNode LABEL() { return getToken(PostgreSqlParser.LABEL, 0); } + public Opt_providerContext opt_provider() { + return getRuleContext(Opt_providerContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Object_type_any_nameContext object_type_any_name() { + return getRuleContext(Object_type_any_nameContext.class,0); + } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } + public Security_labelContext security_label() { + return getRuleContext(Security_labelContext.class,0); + } + public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } + public Object_type_nameContext object_type_name() { + return getRuleContext(Object_type_nameContext.class,0); + } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public Aggregate_with_argtypesContext aggregate_with_argtypes() { + return getRuleContext(Aggregate_with_argtypesContext.class,0); + } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public TerminalNode LARGE_P() { return getToken(PostgreSqlParser.LARGE_P, 0); } + public TerminalNode OBJECT_P() { return getToken(PostgreSqlParser.OBJECT_P, 0); } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public SeclabelstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_seclabelstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSeclabelstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSeclabelstmt(this); + } + } + + public final SeclabelstmtContext seclabelstmt() throws RecognitionException { + SeclabelstmtContext _localctx = new SeclabelstmtContext(_ctx, getState()); + enterRule(_localctx, 538, RULE_seclabelstmt); + try { + setState(4913); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4822); + match(SECURITY); + setState(4823); + match(LABEL); + setState(4824); + opt_provider(); + setState(4825); + match(ON); + setState(4826); + object_type_any_name(); + setState(4827); + any_name(); + setState(4828); + match(IS); + setState(4829); + security_label(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4831); + match(SECURITY); + setState(4832); + match(LABEL); + setState(4833); + opt_provider(); + setState(4834); + match(ON); + setState(4835); + match(COLUMN); + setState(4836); + any_name(); + setState(4837); + match(IS); + setState(4838); + security_label(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4840); + match(SECURITY); + setState(4841); + match(LABEL); + setState(4842); + opt_provider(); + setState(4843); + match(ON); + setState(4844); + object_type_name(); + setState(4845); + name(); + setState(4846); + match(IS); + setState(4847); + security_label(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4849); + match(SECURITY); + setState(4850); + match(LABEL); + setState(4851); + opt_provider(); + setState(4852); + match(ON); + setState(4853); + match(TYPE_P); + setState(4854); + typename(); + setState(4855); + match(IS); + setState(4856); + security_label(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4858); + match(SECURITY); + setState(4859); + match(LABEL); + setState(4860); + opt_provider(); + setState(4861); + match(ON); + setState(4862); + match(DOMAIN_P); + setState(4863); + typename(); + setState(4864); + match(IS); + setState(4865); + security_label(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(4867); + match(SECURITY); + setState(4868); + match(LABEL); + setState(4869); + opt_provider(); + setState(4870); + match(ON); + setState(4871); + match(AGGREGATE); + setState(4872); + aggregate_with_argtypes(); + setState(4873); + match(IS); + setState(4874); + security_label(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(4876); + match(SECURITY); + setState(4877); + match(LABEL); + setState(4878); + opt_provider(); + setState(4879); + match(ON); + setState(4880); + match(FUNCTION); + setState(4881); + function_with_argtypes(); + setState(4882); + match(IS); + setState(4883); + security_label(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(4885); + match(SECURITY); + setState(4886); + match(LABEL); + setState(4887); + opt_provider(); + setState(4888); + match(ON); + setState(4889); + match(LARGE_P); + setState(4890); + match(OBJECT_P); + setState(4891); + numericonly(); + setState(4892); + match(IS); + setState(4893); + security_label(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(4895); + match(SECURITY); + setState(4896); + match(LABEL); + setState(4897); + opt_provider(); + setState(4898); + match(ON); + setState(4899); + match(PROCEDURE); + setState(4900); + function_with_argtypes(); + setState(4901); + match(IS); + setState(4902); + security_label(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(4904); + match(SECURITY); + setState(4905); + match(LABEL); + setState(4906); + opt_provider(); + setState(4907); + match(ON); + setState(4908); + match(ROUTINE); + setState(4909); + function_with_argtypes(); + setState(4910); + match(IS); + setState(4911); + security_label(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_providerContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Nonreservedword_or_sconstContext nonreservedword_or_sconst() { + return getRuleContext(Nonreservedword_or_sconstContext.class,0); + } + public Opt_providerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_provider; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_provider(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_provider(this); + } + } + + public final Opt_providerContext opt_provider() throws RecognitionException { + Opt_providerContext _localctx = new Opt_providerContext(_ctx, getState()); + enterRule(_localctx, 540, RULE_opt_provider); + try { + setState(4918); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(4915); + match(FOR); + setState(4916); + nonreservedword_or_sconst(); + } + break; + case ON: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Security_labelContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public Security_labelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_security_label; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSecurity_label(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSecurity_label(this); + } + } + + public final Security_labelContext security_label() throws RecognitionException { + Security_labelContext _localctx = new Security_labelContext(_ctx, getState()); + enterRule(_localctx, 542, RULE_security_label); + try { + setState(4922); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(4920); + sconst(); + } + break; + case NULL_P: + enterOuterAlt(_localctx, 2); + { + setState(4921); + match(NULL_P); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FetchstmtContext extends ParserRuleContext { + public TerminalNode FETCH() { return getToken(PostgreSqlParser.FETCH, 0); } + public Fetch_argsContext fetch_args() { + return getRuleContext(Fetch_argsContext.class,0); + } + public TerminalNode MOVE() { return getToken(PostgreSqlParser.MOVE, 0); } + public FetchstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fetchstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFetchstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFetchstmt(this); + } + } + + public final FetchstmtContext fetchstmt() throws RecognitionException { + FetchstmtContext _localctx = new FetchstmtContext(_ctx, getState()); + enterRule(_localctx, 544, RULE_fetchstmt); + try { + setState(4928); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FETCH: + enterOuterAlt(_localctx, 1); + { + setState(4924); + match(FETCH); + setState(4925); + fetch_args(); + } + break; + case MOVE: + enterOuterAlt(_localctx, 2); + { + setState(4926); + match(MOVE); + setState(4927); + fetch_args(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Fetch_argsContext extends ParserRuleContext { + public Cursor_nameContext cursor_name() { + return getRuleContext(Cursor_nameContext.class,0); + } + public From_inContext from_in() { + return getRuleContext(From_inContext.class,0); + } + public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } + public Opt_from_inContext opt_from_in() { + return getRuleContext(Opt_from_inContext.class,0); + } + public TerminalNode PRIOR() { return getToken(PostgreSqlParser.PRIOR, 0); } + public TerminalNode FIRST_P() { return getToken(PostgreSqlParser.FIRST_P, 0); } + public TerminalNode LAST_P() { return getToken(PostgreSqlParser.LAST_P, 0); } + public TerminalNode ABSOLUTE_P() { return getToken(PostgreSqlParser.ABSOLUTE_P, 0); } + public SignediconstContext signediconst() { + return getRuleContext(SignediconstContext.class,0); + } + public TerminalNode RELATIVE_P() { return getToken(PostgreSqlParser.RELATIVE_P, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode FORWARD() { return getToken(PostgreSqlParser.FORWARD, 0); } + public TerminalNode BACKWARD() { return getToken(PostgreSqlParser.BACKWARD, 0); } + public Fetch_argsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fetch_args; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFetch_args(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFetch_args(this); + } + } + + public final Fetch_argsContext fetch_args() throws RecognitionException { + Fetch_argsContext _localctx = new Fetch_argsContext(_ctx, getState()); + enterRule(_localctx, 546, RULE_fetch_args); + try { + setState(4996); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4930); + cursor_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4931); + from_in(); + setState(4932); + cursor_name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4934); + match(NEXT); + setState(4935); + opt_from_in(); + setState(4936); + cursor_name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4938); + match(PRIOR); + setState(4939); + opt_from_in(); + setState(4940); + cursor_name(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4942); + match(FIRST_P); + setState(4943); + opt_from_in(); + setState(4944); + cursor_name(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(4946); + match(LAST_P); + setState(4947); + opt_from_in(); + setState(4948); + cursor_name(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(4950); + match(ABSOLUTE_P); + setState(4951); + signediconst(); + setState(4952); + opt_from_in(); + setState(4953); + cursor_name(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(4955); + match(RELATIVE_P); + setState(4956); + signediconst(); + setState(4957); + opt_from_in(); + setState(4958); + cursor_name(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(4960); + signediconst(); + setState(4961); + opt_from_in(); + setState(4962); + cursor_name(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(4964); + match(ALL); + setState(4965); + opt_from_in(); + setState(4966); + cursor_name(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(4968); + match(FORWARD); + setState(4969); + opt_from_in(); + setState(4970); + cursor_name(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(4972); + match(FORWARD); + setState(4973); + signediconst(); + setState(4974); + opt_from_in(); + setState(4975); + cursor_name(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(4977); + match(FORWARD); + setState(4978); + match(ALL); + setState(4979); + opt_from_in(); + setState(4980); + cursor_name(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(4982); + match(BACKWARD); + setState(4983); + opt_from_in(); + setState(4984); + cursor_name(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(4986); + match(BACKWARD); + setState(4987); + signediconst(); + setState(4988); + opt_from_in(); + setState(4989); + cursor_name(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(4991); + match(BACKWARD); + setState(4992); + match(ALL); + setState(4993); + opt_from_in(); + setState(4994); + cursor_name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class From_inContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public From_inContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_from_in; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrom_in(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrom_in(this); + } + } + + public final From_inContext from_in() throws RecognitionException { + From_inContext _localctx = new From_inContext(_ctx, getState()); + enterRule(_localctx, 548, RULE_from_in); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4998); + _la = _input.LA(1); + if ( !(_la==FROM || _la==IN_P) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_from_inContext extends ParserRuleContext { + public From_inContext from_in() { + return getRuleContext(From_inContext.class,0); + } + public Opt_from_inContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_from_in; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_from_in(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_from_in(this); + } + } + + public final Opt_from_inContext opt_from_in() throws RecognitionException { + Opt_from_inContext _localctx = new Opt_from_inContext(_ctx, getState()); + enterRule(_localctx, 550, RULE_opt_from_in); + try { + setState(5002); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FROM: + case IN_P: + enterOuterAlt(_localctx, 1); + { + setState(5000); + from_in(); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GrantstmtContext extends ParserRuleContext { + public TerminalNode GRANT() { return getToken(PostgreSqlParser.GRANT, 0); } + public PrivilegesContext privileges() { + return getRuleContext(PrivilegesContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Privilege_targetContext privilege_target() { + return getRuleContext(Privilege_targetContext.class,0); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Grantee_listContext grantee_list() { + return getRuleContext(Grantee_listContext.class,0); + } + public Opt_grant_grant_optionContext opt_grant_grant_option() { + return getRuleContext(Opt_grant_grant_optionContext.class,0); + } + public GrantstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grantstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrantstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrantstmt(this); + } + } + + public final GrantstmtContext grantstmt() throws RecognitionException { + GrantstmtContext _localctx = new GrantstmtContext(_ctx, getState()); + enterRule(_localctx, 552, RULE_grantstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(5004); + match(GRANT); + setState(5005); + privileges(); + setState(5006); + match(ON); + setState(5007); + privilege_target(); + setState(5008); + match(TO); + setState(5009); + grantee_list(); + setState(5010); + opt_grant_grant_option(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RevokestmtContext extends ParserRuleContext { + public TerminalNode REVOKE() { return getToken(PostgreSqlParser.REVOKE, 0); } + public PrivilegesContext privileges() { + return getRuleContext(PrivilegesContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Privilege_targetContext privilege_target() { + return getRuleContext(Privilege_targetContext.class,0); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public Grantee_listContext grantee_list() { + return getRuleContext(Grantee_listContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode GRANT() { return getToken(PostgreSqlParser.GRANT, 0); } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public RevokestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_revokestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRevokestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRevokestmt(this); + } + } + + public final RevokestmtContext revokestmt() throws RecognitionException { + RevokestmtContext _localctx = new RevokestmtContext(_ctx, getState()); + enterRule(_localctx, 554, RULE_revokestmt); + try { + setState(5031); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,235,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5012); + match(REVOKE); + setState(5013); + privileges(); + setState(5014); + match(ON); + setState(5015); + privilege_target(); + setState(5016); + match(FROM); + setState(5017); + grantee_list(); + setState(5018); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5020); + match(REVOKE); + setState(5021); + match(GRANT); + setState(5022); + match(OPTION); + setState(5023); + match(FOR); + setState(5024); + privileges(); + setState(5025); + match(ON); + setState(5026); + privilege_target(); + setState(5027); + match(FROM); + setState(5028); + grantee_list(); + setState(5029); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrivilegesContext extends ParserRuleContext { + public Privilege_listContext privilege_list() { + return getRuleContext(Privilege_listContext.class,0); + } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode PRIVILEGES() { return getToken(PostgreSqlParser.PRIVILEGES, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public ColumnlistContext columnlist() { + return getRuleContext(ColumnlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public PrivilegesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_privileges; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPrivileges(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPrivileges(this); + } + } + + public final PrivilegesContext privileges() throws RecognitionException { + PrivilegesContext _localctx = new PrivilegesContext(_ctx, getState()); + enterRule(_localctx, 556, RULE_privileges); + try { + setState(5048); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,236,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5033); + privilege_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5034); + match(ALL); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5035); + match(ALL); + setState(5036); + match(PRIVILEGES); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5037); + match(ALL); + setState(5038); + match(OPEN_PAREN); + setState(5039); + columnlist(); + setState(5040); + match(CLOSE_PAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(5042); + match(ALL); + setState(5043); + match(PRIVILEGES); + setState(5044); + match(OPEN_PAREN); + setState(5045); + columnlist(); + setState(5046); + match(CLOSE_PAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Privilege_listContext extends ParserRuleContext { + public List privilege() { + return getRuleContexts(PrivilegeContext.class); + } + public PrivilegeContext privilege(int i) { + return getRuleContext(PrivilegeContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Privilege_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_privilege_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPrivilege_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPrivilege_list(this); + } + } + + public final Privilege_listContext privilege_list() throws RecognitionException { + Privilege_listContext _localctx = new Privilege_listContext(_ctx, getState()); + enterRule(_localctx, 558, RULE_privilege_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5050); + privilege(); + setState(5055); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5051); + match(COMMA); + setState(5052); + privilege(); + } + } + setState(5057); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrivilegeContext extends ParserRuleContext { + public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } + public Opt_column_listContext opt_column_list() { + return getRuleContext(Opt_column_listContext.class,0); + } + public TerminalNode REFERENCES() { return getToken(PostgreSqlParser.REFERENCES, 0); } + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public PrivilegeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_privilege; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPrivilege(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPrivilege(this); + } + } + + public final PrivilegeContext privilege() throws RecognitionException { + PrivilegeContext _localctx = new PrivilegeContext(_ctx, getState()); + enterRule(_localctx, 560, RULE_privilege); + try { + setState(5067); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + enterOuterAlt(_localctx, 1); + { + setState(5058); + match(SELECT); + setState(5059); + opt_column_list(); + } + break; + case REFERENCES: + enterOuterAlt(_localctx, 2); + { + setState(5060); + match(REFERENCES); + setState(5061); + opt_column_list(); + } + break; + case CREATE: + enterOuterAlt(_localctx, 3); + { + setState(5062); + match(CREATE); + setState(5063); + opt_column_list(); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 4); + { + setState(5064); + colid(); + setState(5065); + opt_column_list(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Privilege_targetContext extends ParserRuleContext { + public Qualified_name_listContext qualified_name_list() { + return getRuleContext(Qualified_name_listContext.class,0); + } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } + public Name_listContext name_list() { + return getRuleContext(Name_listContext.class,0); + } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypes_listContext function_with_argtypes_list() { + return getRuleContext(Function_with_argtypes_listContext.class,0); + } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public Any_name_listContext any_name_list() { + return getRuleContext(Any_name_listContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public TerminalNode LARGE_P() { return getToken(PostgreSqlParser.LARGE_P, 0); } + public TerminalNode OBJECT_P() { return getToken(PostgreSqlParser.OBJECT_P, 0); } + public Numericonly_listContext numericonly_list() { + return getRuleContext(Numericonly_listContext.class,0); + } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode TABLES() { return getToken(PostgreSqlParser.TABLES, 0); } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public TerminalNode SEQUENCES() { return getToken(PostgreSqlParser.SEQUENCES, 0); } + public TerminalNode FUNCTIONS() { return getToken(PostgreSqlParser.FUNCTIONS, 0); } + public TerminalNode PROCEDURES() { return getToken(PostgreSqlParser.PROCEDURES, 0); } + public TerminalNode ROUTINES() { return getToken(PostgreSqlParser.ROUTINES, 0); } + public Privilege_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_privilege_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPrivilege_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPrivilege_target(this); + } + } + + public final Privilege_targetContext privilege_target() throws RecognitionException { + Privilege_targetContext _localctx = new Privilege_targetContext(_ctx, getState()); + enterRule(_localctx, 562, RULE_privilege_target); + try { + setState(5127); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,239,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5069); + qualified_name_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5070); + match(TABLE); + setState(5071); + qualified_name_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5072); + match(SEQUENCE); + setState(5073); + qualified_name_list(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5074); + match(FOREIGN); + setState(5075); + match(DATA_P); + setState(5076); + match(WRAPPER); + setState(5077); + name_list(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(5078); + match(FOREIGN); + setState(5079); + match(SERVER); + setState(5080); + name_list(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(5081); + match(FUNCTION); + setState(5082); + function_with_argtypes_list(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(5083); + match(PROCEDURE); + setState(5084); + function_with_argtypes_list(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(5085); + match(ROUTINE); + setState(5086); + function_with_argtypes_list(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(5087); + match(DATABASE); + setState(5088); + name_list(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(5089); + match(DOMAIN_P); + setState(5090); + any_name_list(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(5091); + match(LANGUAGE); + setState(5092); + name_list(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(5093); + match(LARGE_P); + setState(5094); + match(OBJECT_P); + setState(5095); + numericonly_list(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(5096); + match(SCHEMA); + setState(5097); + name_list(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(5098); + match(TABLESPACE); + setState(5099); + name_list(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(5100); + match(TYPE_P); + setState(5101); + any_name_list(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(5102); + match(ALL); + setState(5103); + match(TABLES); + setState(5104); + match(IN_P); + setState(5105); + match(SCHEMA); + setState(5106); + name_list(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(5107); + match(ALL); + setState(5108); + match(SEQUENCES); + setState(5109); + match(IN_P); + setState(5110); + match(SCHEMA); + setState(5111); + name_list(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(5112); + match(ALL); + setState(5113); + match(FUNCTIONS); + setState(5114); + match(IN_P); + setState(5115); + match(SCHEMA); + setState(5116); + name_list(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(5117); + match(ALL); + setState(5118); + match(PROCEDURES); + setState(5119); + match(IN_P); + setState(5120); + match(SCHEMA); + setState(5121); + name_list(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(5122); + match(ALL); + setState(5123); + match(ROUTINES); + setState(5124); + match(IN_P); + setState(5125); + match(SCHEMA); + setState(5126); + name_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Grantee_listContext extends ParserRuleContext { + public List grantee() { + return getRuleContexts(GranteeContext.class); + } + public GranteeContext grantee(int i) { + return getRuleContext(GranteeContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Grantee_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grantee_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrantee_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrantee_list(this); + } + } + + public final Grantee_listContext grantee_list() throws RecognitionException { + Grantee_listContext _localctx = new Grantee_listContext(_ctx, getState()); + enterRule(_localctx, 564, RULE_grantee_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5129); + grantee(); + setState(5134); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5130); + match(COMMA); + setState(5131); + grantee(); + } + } + setState(5136); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GranteeContext extends ParserRuleContext { + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public GranteeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grantee; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrantee(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrantee(this); + } + } + + public final GranteeContext grantee() throws RecognitionException { + GranteeContext _localctx = new GranteeContext(_ctx, getState()); + enterRule(_localctx, 566, RULE_grantee); + try { + setState(5140); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_USER: + case DEFAULT: + case DO: + case FETCH: + case SESSION_USER: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(5137); + rolespec(); + } + break; + case GROUP_P: + enterOuterAlt(_localctx, 2); + { + setState(5138); + match(GROUP_P); + setState(5139); + rolespec(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_grant_grant_optionContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode GRANT() { return getToken(PostgreSqlParser.GRANT, 0); } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public Opt_grant_grant_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_grant_grant_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_grant_grant_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_grant_grant_option(this); + } + } + + public final Opt_grant_grant_optionContext opt_grant_grant_option() throws RecognitionException { + Opt_grant_grant_optionContext _localctx = new Opt_grant_grant_optionContext(_ctx, getState()); + enterRule(_localctx, 568, RULE_opt_grant_grant_option); + try { + setState(5146); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5142); + match(WITH); + setState(5143); + match(GRANT); + setState(5144); + match(OPTION); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GrantrolestmtContext extends ParserRuleContext { + public TerminalNode GRANT() { return getToken(PostgreSqlParser.GRANT, 0); } + public Privilege_listContext privilege_list() { + return getRuleContext(Privilege_listContext.class,0); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public Opt_grant_admin_optionContext opt_grant_admin_option() { + return getRuleContext(Opt_grant_admin_optionContext.class,0); + } + public Opt_granted_byContext opt_granted_by() { + return getRuleContext(Opt_granted_byContext.class,0); + } + public GrantrolestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grantrolestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrantrolestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrantrolestmt(this); + } + } + + public final GrantrolestmtContext grantrolestmt() throws RecognitionException { + GrantrolestmtContext _localctx = new GrantrolestmtContext(_ctx, getState()); + enterRule(_localctx, 570, RULE_grantrolestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(5148); + match(GRANT); + setState(5149); + privilege_list(); + setState(5150); + match(TO); + setState(5151); + role_list(); + setState(5152); + opt_grant_admin_option(); + setState(5153); + opt_granted_by(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RevokerolestmtContext extends ParserRuleContext { + public TerminalNode REVOKE() { return getToken(PostgreSqlParser.REVOKE, 0); } + public Privilege_listContext privilege_list() { + return getRuleContext(Privilege_listContext.class,0); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public Opt_granted_byContext opt_granted_by() { + return getRuleContext(Opt_granted_byContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode ADMIN() { return getToken(PostgreSqlParser.ADMIN, 0); } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public RevokerolestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_revokerolestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRevokerolestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRevokerolestmt(this); + } + } + + public final RevokerolestmtContext revokerolestmt() throws RecognitionException { + RevokerolestmtContext _localctx = new RevokerolestmtContext(_ctx, getState()); + enterRule(_localctx, 572, RULE_revokerolestmt); + try { + setState(5172); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5155); + match(REVOKE); + setState(5156); + privilege_list(); + setState(5157); + match(FROM); + setState(5158); + role_list(); + setState(5159); + opt_granted_by(); + setState(5160); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5162); + match(REVOKE); + setState(5163); + match(ADMIN); + setState(5164); + match(OPTION); + setState(5165); + match(FOR); + setState(5166); + privilege_list(); + setState(5167); + match(FROM); + setState(5168); + role_list(); + setState(5169); + opt_granted_by(); + setState(5170); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_grant_admin_optionContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode ADMIN() { return getToken(PostgreSqlParser.ADMIN, 0); } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public Opt_grant_admin_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_grant_admin_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_grant_admin_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_grant_admin_option(this); + } + } + + public final Opt_grant_admin_optionContext opt_grant_admin_option() throws RecognitionException { + Opt_grant_admin_optionContext _localctx = new Opt_grant_admin_optionContext(_ctx, getState()); + enterRule(_localctx, 574, RULE_opt_grant_admin_option); + try { + setState(5178); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,244,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5174); + match(WITH); + setState(5175); + match(ADMIN); + setState(5176); + match(OPTION); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_granted_byContext extends ParserRuleContext { + public TerminalNode GRANTED() { return getToken(PostgreSqlParser.GRANTED, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public Opt_granted_byContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_granted_by; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_granted_by(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_granted_by(this); + } + } + + public final Opt_granted_byContext opt_granted_by() throws RecognitionException { + Opt_granted_byContext _localctx = new Opt_granted_byContext(_ctx, getState()); + enterRule(_localctx, 576, RULE_opt_granted_by); + try { + setState(5184); + _errHandler.sync(this); + switch (_input.LA(1)) { + case GRANTED: + enterOuterAlt(_localctx, 1); + { + setState(5180); + match(GRANTED); + setState(5181); + match(BY); + setState(5182); + rolespec(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CASCADE: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case RESTRICT: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterdefaultprivilegesstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public TerminalNode PRIVILEGES() { return getToken(PostgreSqlParser.PRIVILEGES, 0); } + public DefacloptionlistContext defacloptionlist() { + return getRuleContext(DefacloptionlistContext.class,0); + } + public DefaclactionContext defaclaction() { + return getRuleContext(DefaclactionContext.class,0); + } + public AlterdefaultprivilegesstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterdefaultprivilegesstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterdefaultprivilegesstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterdefaultprivilegesstmt(this); + } + } + + public final AlterdefaultprivilegesstmtContext alterdefaultprivilegesstmt() throws RecognitionException { + AlterdefaultprivilegesstmtContext _localctx = new AlterdefaultprivilegesstmtContext(_ctx, getState()); + enterRule(_localctx, 578, RULE_alterdefaultprivilegesstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(5186); + match(ALTER); + setState(5187); + match(DEFAULT); + setState(5188); + match(PRIVILEGES); + setState(5189); + defacloptionlist(); + setState(5190); + defaclaction(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DefacloptionlistContext extends ParserRuleContext { + public List defacloption() { + return getRuleContexts(DefacloptionContext.class); + } + public DefacloptionContext defacloption(int i) { + return getRuleContext(DefacloptionContext.class,i); + } + public DefacloptionlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defacloptionlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDefacloptionlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDefacloptionlist(this); + } + } + + public final DefacloptionlistContext defacloptionlist() throws RecognitionException { + DefacloptionlistContext _localctx = new DefacloptionlistContext(_ctx, getState()); + enterRule(_localctx, 580, RULE_defacloptionlist); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5195); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FOR || _la==IN_P) { + { + { + setState(5192); + defacloption(); + } + } + setState(5197); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DefacloptionContext extends ParserRuleContext { + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public Name_listContext name_list() { + return getRuleContext(Name_listContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public Role_listContext role_list() { + return getRuleContext(Role_listContext.class,0); + } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public DefacloptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defacloption; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDefacloption(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDefacloption(this); + } + } + + public final DefacloptionContext defacloption() throws RecognitionException { + DefacloptionContext _localctx = new DefacloptionContext(_ctx, getState()); + enterRule(_localctx, 582, RULE_defacloption); + try { + setState(5207); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,247,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5198); + match(IN_P); + setState(5199); + match(SCHEMA); + setState(5200); + name_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5201); + match(FOR); + setState(5202); + match(ROLE); + setState(5203); + role_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5204); + match(FOR); + setState(5205); + match(USER); + setState(5206); + role_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DefaclactionContext extends ParserRuleContext { + public TerminalNode GRANT() { return getToken(PostgreSqlParser.GRANT, 0); } + public PrivilegesContext privileges() { + return getRuleContext(PrivilegesContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Defacl_privilege_targetContext defacl_privilege_target() { + return getRuleContext(Defacl_privilege_targetContext.class,0); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Grantee_listContext grantee_list() { + return getRuleContext(Grantee_listContext.class,0); + } + public Opt_grant_grant_optionContext opt_grant_grant_option() { + return getRuleContext(Opt_grant_grant_optionContext.class,0); + } + public TerminalNode REVOKE() { return getToken(PostgreSqlParser.REVOKE, 0); } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public DefaclactionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defaclaction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDefaclaction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDefaclaction(this); + } + } + + public final DefaclactionContext defaclaction() throws RecognitionException { + DefaclactionContext _localctx = new DefaclactionContext(_ctx, getState()); + enterRule(_localctx, 584, RULE_defaclaction); + try { + setState(5236); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,248,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5209); + match(GRANT); + setState(5210); + privileges(); + setState(5211); + match(ON); + setState(5212); + defacl_privilege_target(); + setState(5213); + match(TO); + setState(5214); + grantee_list(); + setState(5215); + opt_grant_grant_option(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5217); + match(REVOKE); + setState(5218); + privileges(); + setState(5219); + match(ON); + setState(5220); + defacl_privilege_target(); + setState(5221); + match(FROM); + setState(5222); + grantee_list(); + setState(5223); + opt_drop_behavior(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5225); + match(REVOKE); + setState(5226); + match(GRANT); + setState(5227); + match(OPTION); + setState(5228); + match(FOR); + setState(5229); + privileges(); + setState(5230); + match(ON); + setState(5231); + defacl_privilege_target(); + setState(5232); + match(FROM); + setState(5233); + grantee_list(); + setState(5234); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Defacl_privilege_targetContext extends ParserRuleContext { + public TerminalNode TABLES() { return getToken(PostgreSqlParser.TABLES, 0); } + public TerminalNode FUNCTIONS() { return getToken(PostgreSqlParser.FUNCTIONS, 0); } + public TerminalNode ROUTINES() { return getToken(PostgreSqlParser.ROUTINES, 0); } + public TerminalNode SEQUENCES() { return getToken(PostgreSqlParser.SEQUENCES, 0); } + public TerminalNode TYPES_P() { return getToken(PostgreSqlParser.TYPES_P, 0); } + public TerminalNode SCHEMAS() { return getToken(PostgreSqlParser.SCHEMAS, 0); } + public Defacl_privilege_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defacl_privilege_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDefacl_privilege_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDefacl_privilege_target(this); + } + } + + public final Defacl_privilege_targetContext defacl_privilege_target() throws RecognitionException { + Defacl_privilege_targetContext _localctx = new Defacl_privilege_targetContext(_ctx, getState()); + enterRule(_localctx, 586, RULE_defacl_privilege_target); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5238); + _la = _input.LA(1); + if ( !(_la==FUNCTIONS || ((((_la - 324)) & ~0x3f) == 0 && ((1L << (_la - 324)) & 4297064449L) != 0) || _la==ROUTINES || _la==SCHEMAS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndexstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public Opt_uniqueContext opt_unique() { + return getRuleContext(Opt_uniqueContext.class,0); + } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public Opt_concurrentlyContext opt_concurrently() { + return getRuleContext(Opt_concurrentlyContext.class,0); + } + public Opt_index_nameContext opt_index_name() { + return getRuleContext(Opt_index_nameContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Relation_exprContext relation_expr() { + return getRuleContext(Relation_exprContext.class,0); + } + public Access_method_clauseContext access_method_clause() { + return getRuleContext(Access_method_clauseContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Index_paramsContext index_params() { + return getRuleContext(Index_paramsContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_includeContext opt_include() { + return getRuleContext(Opt_includeContext.class,0); + } + public Opt_reloptionsContext opt_reloptions() { + return getRuleContext(Opt_reloptionsContext.class,0); + } + public OpttablespaceContext opttablespace() { + return getRuleContext(OpttablespaceContext.class,0); + } + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public IndexstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndexstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndexstmt(this); + } + } + + public final IndexstmtContext indexstmt() throws RecognitionException { + IndexstmtContext _localctx = new IndexstmtContext(_ctx, getState()); + enterRule(_localctx, 588, RULE_indexstmt); + try { + setState(5275); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,249,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5240); + match(CREATE); + setState(5241); + opt_unique(); + setState(5242); + match(INDEX); + setState(5243); + opt_concurrently(); + setState(5244); + opt_index_name(); + setState(5245); + match(ON); + setState(5246); + relation_expr(); + setState(5247); + access_method_clause(); + setState(5248); + match(OPEN_PAREN); + setState(5249); + index_params(); + setState(5250); + match(CLOSE_PAREN); + setState(5251); + opt_include(); + setState(5252); + opt_reloptions(); + setState(5253); + opttablespace(); + setState(5254); + where_clause(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5256); + match(CREATE); + setState(5257); + opt_unique(); + setState(5258); + match(INDEX); + setState(5259); + opt_concurrently(); + setState(5260); + match(IF_P); + setState(5261); + match(NOT); + setState(5262); + match(EXISTS); + setState(5263); + name(); + setState(5264); + match(ON); + setState(5265); + relation_expr(); + setState(5266); + access_method_clause(); + setState(5267); + match(OPEN_PAREN); + setState(5268); + index_params(); + setState(5269); + match(CLOSE_PAREN); + setState(5270); + opt_include(); + setState(5271); + opt_reloptions(); + setState(5272); + opttablespace(); + setState(5273); + where_clause(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_uniqueContext extends ParserRuleContext { + public TerminalNode UNIQUE() { return getToken(PostgreSqlParser.UNIQUE, 0); } + public Opt_uniqueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_unique; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_unique(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_unique(this); + } + } + + public final Opt_uniqueContext opt_unique() throws RecognitionException { + Opt_uniqueContext _localctx = new Opt_uniqueContext(_ctx, getState()); + enterRule(_localctx, 590, RULE_opt_unique); + try { + setState(5279); + _errHandler.sync(this); + switch (_input.LA(1)) { + case UNIQUE: + enterOuterAlt(_localctx, 1); + { + setState(5277); + match(UNIQUE); + } + break; + case INDEX: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_concurrentlyContext extends ParserRuleContext { + public TerminalNode CONCURRENTLY() { return getToken(PostgreSqlParser.CONCURRENTLY, 0); } + public Opt_concurrentlyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_concurrently; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_concurrently(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_concurrently(this); + } + } + + public final Opt_concurrentlyContext opt_concurrently() throws RecognitionException { + Opt_concurrentlyContext _localctx = new Opt_concurrentlyContext(_ctx, getState()); + enterRule(_localctx, 592, RULE_opt_concurrently); + try { + setState(5283); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CONCURRENTLY: + enterOuterAlt(_localctx, 1); + { + setState(5281); + match(CONCURRENTLY); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case ON: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_index_nameContext extends ParserRuleContext { + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_index_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_index_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_index_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_index_name(this); + } + } + + public final Opt_index_nameContext opt_index_name() throws RecognitionException { + Opt_index_nameContext _localctx = new Opt_index_nameContext(_ctx, getState()); + enterRule(_localctx, 594, RULE_opt_index_name); + try { + setState(5287); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(5285); + name(); + } + break; + case ON: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Access_method_clauseContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Access_method_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_access_method_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAccess_method_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAccess_method_clause(this); + } + } + + public final Access_method_clauseContext access_method_clause() throws RecognitionException { + Access_method_clauseContext _localctx = new Access_method_clauseContext(_ctx, getState()); + enterRule(_localctx, 596, RULE_access_method_clause); + try { + setState(5292); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(5289); + match(USING); + setState(5290); + name(); + } + break; + case OPEN_PAREN: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Index_paramsContext extends ParserRuleContext { + public List index_elem() { + return getRuleContexts(Index_elemContext.class); + } + public Index_elemContext index_elem(int i) { + return getRuleContext(Index_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Index_paramsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_index_params; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndex_params(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndex_params(this); + } + } + + public final Index_paramsContext index_params() throws RecognitionException { + Index_paramsContext _localctx = new Index_paramsContext(_ctx, getState()); + enterRule(_localctx, 598, RULE_index_params); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5294); + index_elem(); + setState(5299); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5295); + match(COMMA); + setState(5296); + index_elem(); + } + } + setState(5301); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Index_elem_optionsContext extends ParserRuleContext { + public Opt_collateContext opt_collate() { + return getRuleContext(Opt_collateContext.class,0); + } + public Opt_classContext opt_class() { + return getRuleContext(Opt_classContext.class,0); + } + public Opt_asc_descContext opt_asc_desc() { + return getRuleContext(Opt_asc_descContext.class,0); + } + public Opt_nulls_orderContext opt_nulls_order() { + return getRuleContext(Opt_nulls_orderContext.class,0); + } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public ReloptionsContext reloptions() { + return getRuleContext(ReloptionsContext.class,0); + } + public Index_elem_optionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_index_elem_options; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndex_elem_options(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndex_elem_options(this); + } + } + + public final Index_elem_optionsContext index_elem_options() throws RecognitionException { + Index_elem_optionsContext _localctx = new Index_elem_optionsContext(_ctx, getState()); + enterRule(_localctx, 600, RULE_index_elem_options); + try { + setState(5313); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,255,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5302); + opt_collate(); + setState(5303); + opt_class(); + setState(5304); + opt_asc_desc(); + setState(5305); + opt_nulls_order(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5307); + opt_collate(); + setState(5308); + any_name(); + setState(5309); + reloptions(); + setState(5310); + opt_asc_desc(); + setState(5311); + opt_nulls_order(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Index_elemContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Index_elem_optionsContext index_elem_options() { + return getRuleContext(Index_elem_optionsContext.class,0); + } + public Func_expr_windowlessContext func_expr_windowless() { + return getRuleContext(Func_expr_windowlessContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Index_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_index_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndex_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndex_elem(this); + } + } + + public final Index_elemContext index_elem() throws RecognitionException { + Index_elemContext _localctx = new Index_elemContext(_ctx, getState()); + enterRule(_localctx, 602, RULE_index_elem); + try { + setState(5326); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,256,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5315); + colid(); + setState(5316); + index_elem_options(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5318); + func_expr_windowless(); + setState(5319); + index_elem_options(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5321); + match(OPEN_PAREN); + setState(5322); + a_expr(); + setState(5323); + match(CLOSE_PAREN); + setState(5324); + index_elem_options(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_includeContext extends ParserRuleContext { + public TerminalNode INCLUDE() { return getToken(PostgreSqlParser.INCLUDE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Index_including_paramsContext index_including_params() { + return getRuleContext(Index_including_paramsContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_includeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_include; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_include(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_include(this); + } + } + + public final Opt_includeContext opt_include() throws RecognitionException { + Opt_includeContext _localctx = new Opt_includeContext(_ctx, getState()); + enterRule(_localctx, 604, RULE_opt_include); + try { + setState(5334); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INCLUDE: + enterOuterAlt(_localctx, 1); + { + setState(5328); + match(INCLUDE); + setState(5329); + match(OPEN_PAREN); + setState(5330); + index_including_params(); + setState(5331); + match(CLOSE_PAREN); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WHERE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TABLESPACE: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Index_including_paramsContext extends ParserRuleContext { + public List index_elem() { + return getRuleContexts(Index_elemContext.class); + } + public Index_elemContext index_elem(int i) { + return getRuleContext(Index_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Index_including_paramsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_index_including_params; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndex_including_params(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndex_including_params(this); + } + } + + public final Index_including_paramsContext index_including_params() throws RecognitionException { + Index_including_paramsContext _localctx = new Index_including_paramsContext(_ctx, getState()); + enterRule(_localctx, 606, RULE_index_including_params); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5336); + index_elem(); + setState(5341); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5337); + match(COMMA); + setState(5338); + index_elem(); + } + } + setState(5343); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_collateContext extends ParserRuleContext { + public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Opt_collateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_collate; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_collate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_collate(this); + } + } + + public final Opt_collateContext opt_collate() throws RecognitionException { + Opt_collateContext _localctx = new Opt_collateContext(_ctx, getState()); + enterRule(_localctx, 608, RULE_opt_collate); + try { + setState(5347); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,259,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5344); + match(COLLATE); + setState(5345); + any_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_classContext extends ParserRuleContext { + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Opt_classContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_class; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_class(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_class(this); + } + } + + public final Opt_classContext opt_class() throws RecognitionException { + Opt_classContext _localctx = new Opt_classContext(_ctx, getState()); + enterRule(_localctx, 610, RULE_opt_class); + try { + setState(5351); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,260,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5349); + any_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_asc_descContext extends ParserRuleContext { + public TerminalNode ASC() { return getToken(PostgreSqlParser.ASC, 0); } + public TerminalNode DESC() { return getToken(PostgreSqlParser.DESC, 0); } + public Opt_asc_descContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_asc_desc; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_asc_desc(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_asc_desc(this); + } + } + + public final Opt_asc_descContext opt_asc_desc() throws RecognitionException { + Opt_asc_descContext _localctx = new Opt_asc_descContext(_ctx, getState()); + enterRule(_localctx, 612, RULE_opt_asc_desc); + try { + setState(5356); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ASC: + enterOuterAlt(_localctx, 1); + { + setState(5353); + match(ASC); + } + break; + case DESC: + enterOuterAlt(_localctx, 2); + { + setState(5354); + match(DESC); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case FOR: + case GRANT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case RETURNING: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case NULLS_P: + case PREPARE: + case RANGE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case ROWS: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case GROUPS: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_nulls_orderContext extends ParserRuleContext { + public TerminalNode NULLS_P() { return getToken(PostgreSqlParser.NULLS_P, 0); } + public TerminalNode FIRST_P() { return getToken(PostgreSqlParser.FIRST_P, 0); } + public TerminalNode LAST_P() { return getToken(PostgreSqlParser.LAST_P, 0); } + public Opt_nulls_orderContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_nulls_order; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_nulls_order(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_nulls_order(this); + } + } + + public final Opt_nulls_orderContext opt_nulls_order() throws RecognitionException { + Opt_nulls_orderContext _localctx = new Opt_nulls_orderContext(_ctx, getState()); + enterRule(_localctx, 614, RULE_opt_nulls_order); + try { + setState(5363); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5358); + match(NULLS_P); + setState(5359); + match(FIRST_P); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5360); + match(NULLS_P); + setState(5361); + match(LAST_P); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatefunctionstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public Opt_or_replaceContext opt_or_replace() { + return getRuleContext(Opt_or_replaceContext.class,0); + } + public Func_nameContext func_name() { + return getRuleContext(Func_nameContext.class,0); + } + public Func_args_with_defaultsContext func_args_with_defaults() { + return getRuleContext(Func_args_with_defaultsContext.class,0); + } + public Createfunc_opt_listContext createfunc_opt_list() { + return getRuleContext(Createfunc_opt_listContext.class,0); + } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode RETURNS() { return getToken(PostgreSqlParser.RETURNS, 0); } + public Func_returnContext func_return() { + return getRuleContext(Func_returnContext.class,0); + } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Table_func_column_listContext table_func_column_list() { + return getRuleContext(Table_func_column_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public CreatefunctionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createfunctionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatefunctionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatefunctionstmt(this); + } + } + + public final CreatefunctionstmtContext createfunctionstmt() throws RecognitionException { + CreatefunctionstmtContext _localctx = new CreatefunctionstmtContext(_ctx, getState()); + enterRule(_localctx, 616, RULE_createfunctionstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5365); + match(CREATE); + setState(5366); + opt_or_replace(); + setState(5367); + _la = _input.LA(1); + if ( !(_la==FUNCTION || _la==PROCEDURE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5368); + func_name(); + setState(5369); + func_args_with_defaults(); + setState(5379); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,264,_ctx) ) { + case 1: + { + setState(5370); + match(RETURNS); + setState(5377); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,263,_ctx) ) { + case 1: + { + setState(5371); + func_return(); + } + break; + case 2: + { + setState(5372); + match(TABLE); + setState(5373); + match(OPEN_PAREN); + setState(5374); + table_func_column_list(); + setState(5375); + match(CLOSE_PAREN); + } + break; + } + } + break; + } + setState(5381); + createfunc_opt_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_or_replaceContext extends ParserRuleContext { + public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } + public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } + public Opt_or_replaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_or_replace; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_or_replace(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_or_replace(this); + } + } + + public final Opt_or_replaceContext opt_or_replace() throws RecognitionException { + Opt_or_replaceContext _localctx = new Opt_or_replaceContext(_ctx, getState()); + enterRule(_localctx, 618, RULE_opt_or_replace); + try { + setState(5386); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OR: + enterOuterAlt(_localctx, 1); + { + setState(5383); + match(OR); + setState(5384); + match(REPLACE); + } + break; + case AGGREGATE: + case FUNCTION: + case LANGUAGE: + case PROCEDURAL: + case PROCEDURE: + case RULE: + case TRUSTED: + case TRANSFORM: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_argsContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Func_args_listContext func_args_list() { + return getRuleContext(Func_args_listContext.class,0); + } + public Func_argsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_args; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_args(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_args(this); + } + } + + public final Func_argsContext func_args() throws RecognitionException { + Func_argsContext _localctx = new Func_argsContext(_ctx, getState()); + enterRule(_localctx, 620, RULE_func_args); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5388); + match(OPEN_PAREN); + setState(5390); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 35)) & ~0x3f) == 0 && ((1L << (_la - 35)) & 576460786949430277L) != 0) || ((((_la - 103)) & ~0x3f) == 0 && ((1L << (_la - 103)) & -31L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & -1L) != 0) || ((((_la - 231)) & ~0x3f) == 0 && ((1L << (_la - 231)) & -18874369L) != 0) || ((((_la - 295)) & ~0x3f) == 0 && ((1L << (_la - 295)) & -1L) != 0) || ((((_la - 359)) & ~0x3f) == 0 && ((1L << (_la - 359)) & -1L) != 0) || ((((_la - 423)) & ~0x3f) == 0 && ((1L << (_la - 423)) & -8589934593L) != 0) || ((((_la - 487)) & ~0x3f) == 0 && ((1L << (_la - 487)) & -85900656641L) != 0) || ((((_la - 551)) & ~0x3f) == 0 && ((1L << (_la - 551)) & -1L) != 0) || ((((_la - 615)) & ~0x3f) == 0 && ((1L << (_la - 615)) & 562950557401087L) != 0)) { + { + setState(5389); + func_args_list(); + } + } + + setState(5392); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_args_listContext extends ParserRuleContext { + public List func_arg() { + return getRuleContexts(Func_argContext.class); + } + public Func_argContext func_arg(int i) { + return getRuleContext(Func_argContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Func_args_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_args_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_args_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_args_list(this); + } + } + + public final Func_args_listContext func_args_list() throws RecognitionException { + Func_args_listContext _localctx = new Func_args_listContext(_ctx, getState()); + enterRule(_localctx, 622, RULE_func_args_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5394); + func_arg(); + setState(5399); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5395); + match(COMMA); + setState(5396); + func_arg(); + } + } + setState(5401); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Function_with_argtypes_listContext extends ParserRuleContext { + public List function_with_argtypes() { + return getRuleContexts(Function_with_argtypesContext.class); + } + public Function_with_argtypesContext function_with_argtypes(int i) { + return getRuleContext(Function_with_argtypesContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Function_with_argtypes_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_function_with_argtypes_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunction_with_argtypes_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunction_with_argtypes_list(this); + } + } + + public final Function_with_argtypes_listContext function_with_argtypes_list() throws RecognitionException { + Function_with_argtypes_listContext _localctx = new Function_with_argtypes_listContext(_ctx, getState()); + enterRule(_localctx, 624, RULE_function_with_argtypes_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5402); + function_with_argtypes(); + setState(5407); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5403); + match(COMMA); + setState(5404); + function_with_argtypes(); + } + } + setState(5409); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Function_with_argtypesContext extends ParserRuleContext { + public Func_nameContext func_name() { + return getRuleContext(Func_nameContext.class,0); + } + public Func_argsContext func_args() { + return getRuleContext(Func_argsContext.class,0); + } + public Type_func_name_keywordContext type_func_name_keyword() { + return getRuleContext(Type_func_name_keywordContext.class,0); + } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public IndirectionContext indirection() { + return getRuleContext(IndirectionContext.class,0); + } + public Function_with_argtypesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_function_with_argtypes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunction_with_argtypes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunction_with_argtypes(this); + } + } + + public final Function_with_argtypesContext function_with_argtypes() throws RecognitionException { + Function_with_argtypesContext _localctx = new Function_with_argtypesContext(_ctx, getState()); + enterRule(_localctx, 626, RULE_function_with_argtypes); + int _la; + try { + setState(5418); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,270,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5410); + func_name(); + setState(5411); + func_args(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5413); + type_func_name_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5414); + colid(); + setState(5416); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET || _la==DOT) { + { + setState(5415); + indirection(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_args_with_defaultsContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Func_args_with_defaults_listContext func_args_with_defaults_list() { + return getRuleContext(Func_args_with_defaults_listContext.class,0); + } + public Func_args_with_defaultsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_args_with_defaults; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_args_with_defaults(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_args_with_defaults(this); + } + } + + public final Func_args_with_defaultsContext func_args_with_defaults() throws RecognitionException { + Func_args_with_defaultsContext _localctx = new Func_args_with_defaultsContext(_ctx, getState()); + enterRule(_localctx, 628, RULE_func_args_with_defaults); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5420); + match(OPEN_PAREN); + setState(5422); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 35)) & ~0x3f) == 0 && ((1L << (_la - 35)) & 576460786949430277L) != 0) || ((((_la - 103)) & ~0x3f) == 0 && ((1L << (_la - 103)) & -31L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & -1L) != 0) || ((((_la - 231)) & ~0x3f) == 0 && ((1L << (_la - 231)) & -18874369L) != 0) || ((((_la - 295)) & ~0x3f) == 0 && ((1L << (_la - 295)) & -1L) != 0) || ((((_la - 359)) & ~0x3f) == 0 && ((1L << (_la - 359)) & -1L) != 0) || ((((_la - 423)) & ~0x3f) == 0 && ((1L << (_la - 423)) & -8589934593L) != 0) || ((((_la - 487)) & ~0x3f) == 0 && ((1L << (_la - 487)) & -85900656641L) != 0) || ((((_la - 551)) & ~0x3f) == 0 && ((1L << (_la - 551)) & -1L) != 0) || ((((_la - 615)) & ~0x3f) == 0 && ((1L << (_la - 615)) & 562950557401087L) != 0)) { + { + setState(5421); + func_args_with_defaults_list(); + } + } + + setState(5424); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_args_with_defaults_listContext extends ParserRuleContext { + public List func_arg_with_default() { + return getRuleContexts(Func_arg_with_defaultContext.class); + } + public Func_arg_with_defaultContext func_arg_with_default(int i) { + return getRuleContext(Func_arg_with_defaultContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Func_args_with_defaults_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_args_with_defaults_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_args_with_defaults_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_args_with_defaults_list(this); + } + } + + public final Func_args_with_defaults_listContext func_args_with_defaults_list() throws RecognitionException { + Func_args_with_defaults_listContext _localctx = new Func_args_with_defaults_listContext(_ctx, getState()); + enterRule(_localctx, 630, RULE_func_args_with_defaults_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5426); + func_arg_with_default(); + setState(5431); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5427); + match(COMMA); + setState(5428); + func_arg_with_default(); + } + } + setState(5433); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_argContext extends ParserRuleContext { + public Arg_classContext arg_class() { + return getRuleContext(Arg_classContext.class,0); + } + public Func_typeContext func_type() { + return getRuleContext(Func_typeContext.class,0); + } + public Param_nameContext param_name() { + return getRuleContext(Param_nameContext.class,0); + } + public Func_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_arg(this); + } + } + + public final Func_argContext func_arg() throws RecognitionException { + Func_argContext _localctx = new Func_argContext(_ctx, getState()); + enterRule(_localctx, 632, RULE_func_arg); + try { + setState(5447); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,275,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5434); + arg_class(); + setState(5436); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,273,_ctx) ) { + case 1: + { + setState(5435); + param_name(); + } + break; + } + setState(5438); + func_type(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5440); + param_name(); + setState(5442); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,274,_ctx) ) { + case 1: + { + setState(5441); + arg_class(); + } + break; + } + setState(5444); + func_type(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5446); + func_type(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Arg_classContext extends ParserRuleContext { + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public TerminalNode OUT_P() { return getToken(PostgreSqlParser.OUT_P, 0); } + public TerminalNode INOUT() { return getToken(PostgreSqlParser.INOUT, 0); } + public TerminalNode VARIADIC() { return getToken(PostgreSqlParser.VARIADIC, 0); } + public Arg_classContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arg_class; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterArg_class(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitArg_class(this); + } + } + + public final Arg_classContext arg_class() throws RecognitionException { + Arg_classContext _localctx = new Arg_classContext(_ctx, getState()); + enterRule(_localctx, 634, RULE_arg_class); + try { + setState(5456); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IN_P: + enterOuterAlt(_localctx, 1); + { + setState(5449); + match(IN_P); + setState(5451); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,276,_ctx) ) { + case 1: + { + setState(5450); + match(OUT_P); + } + break; + } + } + break; + case OUT_P: + enterOuterAlt(_localctx, 2); + { + setState(5453); + match(OUT_P); + } + break; + case INOUT: + enterOuterAlt(_localctx, 3); + { + setState(5454); + match(INOUT); + } + break; + case VARIADIC: + enterOuterAlt(_localctx, 4); + { + setState(5455); + match(VARIADIC); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Param_nameContext extends ParserRuleContext { + public Type_function_nameContext type_function_name() { + return getRuleContext(Type_function_nameContext.class,0); + } + public Builtin_function_nameContext builtin_function_name() { + return getRuleContext(Builtin_function_nameContext.class,0); + } + public TerminalNode LEFT() { return getToken(PostgreSqlParser.LEFT, 0); } + public TerminalNode RIGHT() { return getToken(PostgreSqlParser.RIGHT, 0); } + public Param_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_param_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterParam_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitParam_name(this); + } + } + + public final Param_nameContext param_name() throws RecognitionException { + Param_nameContext _localctx = new Param_nameContext(_ctx, getState()); + enterRule(_localctx, 636, RULE_param_name); + try { + setState(5462); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case COLUMNS: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(5458); + type_function_name(); + } + break; + case REPLACE: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case REVERSE: + case LOG: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + enterOuterAlt(_localctx, 2); + { + setState(5459); + builtin_function_name(); + } + break; + case LEFT: + enterOuterAlt(_localctx, 3); + { + setState(5460); + match(LEFT); + } + break; + case RIGHT: + enterOuterAlt(_localctx, 4); + { + setState(5461); + match(RIGHT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_returnContext extends ParserRuleContext { + public Func_typeContext func_type() { + return getRuleContext(Func_typeContext.class,0); + } + public Func_returnContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_return; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_return(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_return(this); + } + } + + public final Func_returnContext func_return() throws RecognitionException { + Func_returnContext _localctx = new Func_returnContext(_ctx, getState()); + enterRule(_localctx, 638, RULE_func_return); + try { + enterOuterAlt(_localctx, 1); + { + setState(5464); + func_type(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_typeContext extends ParserRuleContext { + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public AttrsContext attrs() { + return getRuleContext(AttrsContext.class,0); + } + public TerminalNode PERCENT() { return getToken(PostgreSqlParser.PERCENT, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public Builtin_function_nameContext builtin_function_name() { + return getRuleContext(Builtin_function_nameContext.class,0); + } + public Type_function_nameContext type_function_name() { + return getRuleContext(Type_function_nameContext.class,0); + } + public TerminalNode LEFT() { return getToken(PostgreSqlParser.LEFT, 0); } + public TerminalNode RIGHT() { return getToken(PostgreSqlParser.RIGHT, 0); } + public TerminalNode SETOF() { return getToken(PostgreSqlParser.SETOF, 0); } + public Func_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_type(this); + } + } + + public final Func_typeContext func_type() throws RecognitionException { + Func_typeContext _localctx = new Func_typeContext(_ctx, getState()); + enterRule(_localctx, 640, RULE_func_type); + int _la; + try { + setState(5480); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,281,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5466); + typename(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5468); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SETOF) { + { + setState(5467); + match(SETOF); + } + } + + setState(5474); + _errHandler.sync(this); + switch (_input.LA(1)) { + case REPLACE: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case REVERSE: + case LOG: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + { + setState(5470); + builtin_function_name(); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case COLUMNS: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(5471); + type_function_name(); + } + break; + case LEFT: + { + setState(5472); + match(LEFT); + } + break; + case RIGHT: + { + setState(5473); + match(RIGHT); + } + break; + default: + throw new NoViableAltException(this); + } + setState(5476); + attrs(); + setState(5477); + match(PERCENT); + setState(5478); + match(TYPE_P); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_arg_with_defaultContext extends ParserRuleContext { + public Func_argContext func_arg() { + return getRuleContext(Func_argContext.class,0); + } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public Func_arg_with_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_arg_with_default; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_arg_with_default(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_arg_with_default(this); + } + } + + public final Func_arg_with_defaultContext func_arg_with_default() throws RecognitionException { + Func_arg_with_defaultContext _localctx = new Func_arg_with_defaultContext(_ctx, getState()); + enterRule(_localctx, 642, RULE_func_arg_with_default); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5482); + func_arg(); + setState(5485); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL || _la==DEFAULT) { + { + setState(5483); + _la = _input.LA(1); + if ( !(_la==EQUAL || _la==DEFAULT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5484); + a_expr(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Aggr_argContext extends ParserRuleContext { + public Func_argContext func_arg() { + return getRuleContext(Func_argContext.class,0); + } + public Aggr_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_aggr_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAggr_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAggr_arg(this); + } + } + + public final Aggr_argContext aggr_arg() throws RecognitionException { + Aggr_argContext _localctx = new Aggr_argContext(_ctx, getState()); + enterRule(_localctx, 644, RULE_aggr_arg); + try { + enterOuterAlt(_localctx, 1); + { + setState(5487); + func_arg(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Aggr_argsContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public List aggr_args_list() { + return getRuleContexts(Aggr_args_listContext.class); + } + public Aggr_args_listContext aggr_args_list(int i) { + return getRuleContext(Aggr_args_listContext.class,i); + } + public TerminalNode ORDER() { return getToken(PostgreSqlParser.ORDER, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Aggr_argsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_aggr_args; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAggr_args(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAggr_args(this); + } + } + + public final Aggr_argsContext aggr_args() throws RecognitionException { + Aggr_argsContext _localctx = new Aggr_argsContext(_ctx, getState()); + enterRule(_localctx, 646, RULE_aggr_args); + try { + enterOuterAlt(_localctx, 1); + { + setState(5489); + match(OPEN_PAREN); + setState(5500); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,283,_ctx) ) { + case 1: + { + setState(5490); + match(STAR); + } + break; + case 2: + { + setState(5491); + aggr_args_list(); + } + break; + case 3: + { + setState(5492); + match(ORDER); + setState(5493); + match(BY); + setState(5494); + aggr_args_list(); + } + break; + case 4: + { + setState(5495); + aggr_args_list(); + setState(5496); + match(ORDER); + setState(5497); + match(BY); + setState(5498); + aggr_args_list(); + } + break; + } + setState(5502); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Aggr_args_listContext extends ParserRuleContext { + public List aggr_arg() { + return getRuleContexts(Aggr_argContext.class); + } + public Aggr_argContext aggr_arg(int i) { + return getRuleContext(Aggr_argContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Aggr_args_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_aggr_args_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAggr_args_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAggr_args_list(this); + } + } + + public final Aggr_args_listContext aggr_args_list() throws RecognitionException { + Aggr_args_listContext _localctx = new Aggr_args_listContext(_ctx, getState()); + enterRule(_localctx, 648, RULE_aggr_args_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5504); + aggr_arg(); + setState(5509); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5505); + match(COMMA); + setState(5506); + aggr_arg(); + } + } + setState(5511); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Aggregate_with_argtypesContext extends ParserRuleContext { + public Func_nameContext func_name() { + return getRuleContext(Func_nameContext.class,0); + } + public Aggr_argsContext aggr_args() { + return getRuleContext(Aggr_argsContext.class,0); + } + public Aggregate_with_argtypesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_aggregate_with_argtypes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAggregate_with_argtypes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAggregate_with_argtypes(this); + } + } + + public final Aggregate_with_argtypesContext aggregate_with_argtypes() throws RecognitionException { + Aggregate_with_argtypesContext _localctx = new Aggregate_with_argtypesContext(_ctx, getState()); + enterRule(_localctx, 650, RULE_aggregate_with_argtypes); + try { + enterOuterAlt(_localctx, 1); + { + setState(5512); + func_name(); + setState(5513); + aggr_args(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Aggregate_with_argtypes_listContext extends ParserRuleContext { + public List aggregate_with_argtypes() { + return getRuleContexts(Aggregate_with_argtypesContext.class); + } + public Aggregate_with_argtypesContext aggregate_with_argtypes(int i) { + return getRuleContext(Aggregate_with_argtypesContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Aggregate_with_argtypes_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_aggregate_with_argtypes_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAggregate_with_argtypes_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAggregate_with_argtypes_list(this); + } + } + + public final Aggregate_with_argtypes_listContext aggregate_with_argtypes_list() throws RecognitionException { + Aggregate_with_argtypes_listContext _localctx = new Aggregate_with_argtypes_listContext(_ctx, getState()); + enterRule(_localctx, 652, RULE_aggregate_with_argtypes_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5515); + aggregate_with_argtypes(); + setState(5520); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5516); + match(COMMA); + setState(5517); + aggregate_with_argtypes(); + } + } + setState(5522); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Createfunc_opt_listContext extends ParserRuleContext { + public List createfunc_opt_item() { + return getRuleContexts(Createfunc_opt_itemContext.class); + } + public Createfunc_opt_itemContext createfunc_opt_item(int i) { + return getRuleContext(Createfunc_opt_itemContext.class,i); + } + public Createfunc_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createfunc_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatefunc_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatefunc_opt_list(this); + } + } + + public final Createfunc_opt_listContext createfunc_opt_list() throws RecognitionException { + Createfunc_opt_listContext _localctx = new Createfunc_opt_listContext(_ctx, getState()); + enterRule(_localctx, 654, RULE_createfunc_opt_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(5524); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(5523); + createfunc_opt_item(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(5526); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,286,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + + ParseRoutineBody(_localctx); + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Common_func_opt_itemContext extends ParserRuleContext { + public TerminalNode CALLED() { return getToken(PostgreSqlParser.CALLED, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public List NULL_P() { return getTokens(PostgreSqlParser.NULL_P); } + public TerminalNode NULL_P(int i) { + return getToken(PostgreSqlParser.NULL_P, i); + } + public TerminalNode INPUT_P() { return getToken(PostgreSqlParser.INPUT_P, 0); } + public TerminalNode RETURNS() { return getToken(PostgreSqlParser.RETURNS, 0); } + public TerminalNode STRICT_P() { return getToken(PostgreSqlParser.STRICT_P, 0); } + public TerminalNode IMMUTABLE() { return getToken(PostgreSqlParser.IMMUTABLE, 0); } + public TerminalNode STABLE() { return getToken(PostgreSqlParser.STABLE, 0); } + public TerminalNode VOLATILE() { return getToken(PostgreSqlParser.VOLATILE, 0); } + public TerminalNode EXTERNAL() { return getToken(PostgreSqlParser.EXTERNAL, 0); } + public TerminalNode SECURITY() { return getToken(PostgreSqlParser.SECURITY, 0); } + public TerminalNode DEFINER() { return getToken(PostgreSqlParser.DEFINER, 0); } + public TerminalNode INVOKER() { return getToken(PostgreSqlParser.INVOKER, 0); } + public TerminalNode LEAKPROOF() { return getToken(PostgreSqlParser.LEAKPROOF, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode COST() { return getToken(PostgreSqlParser.COST, 0); } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } + public TerminalNode SUPPORT() { return getToken(PostgreSqlParser.SUPPORT, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public FunctionsetresetclauseContext functionsetresetclause() { + return getRuleContext(FunctionsetresetclauseContext.class,0); + } + public TerminalNode PARALLEL() { return getToken(PostgreSqlParser.PARALLEL, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Common_func_opt_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_common_func_opt_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCommon_func_opt_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCommon_func_opt_item(this); + } + } + + public final Common_func_opt_itemContext common_func_opt_item() throws RecognitionException { + Common_func_opt_itemContext _localctx = new Common_func_opt_itemContext(_ctx, getState()); + enterRule(_localctx, 656, RULE_common_func_opt_item); + try { + setState(5565); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5530); + match(CALLED); + setState(5531); + match(ON); + setState(5532); + match(NULL_P); + setState(5533); + match(INPUT_P); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5534); + match(RETURNS); + setState(5535); + match(NULL_P); + setState(5536); + match(ON); + setState(5537); + match(NULL_P); + setState(5538); + match(INPUT_P); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5539); + match(STRICT_P); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5540); + match(IMMUTABLE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(5541); + match(STABLE); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(5542); + match(VOLATILE); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(5543); + match(EXTERNAL); + setState(5544); + match(SECURITY); + setState(5545); + match(DEFINER); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(5546); + match(EXTERNAL); + setState(5547); + match(SECURITY); + setState(5548); + match(INVOKER); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(5549); + match(SECURITY); + setState(5550); + match(DEFINER); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(5551); + match(SECURITY); + setState(5552); + match(INVOKER); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(5553); + match(LEAKPROOF); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(5554); + match(NOT); + setState(5555); + match(LEAKPROOF); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(5556); + match(COST); + setState(5557); + numericonly(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(5558); + match(ROWS); + setState(5559); + numericonly(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(5560); + match(SUPPORT); + setState(5561); + any_name(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(5562); + functionsetresetclause(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(5563); + match(PARALLEL); + setState(5564); + colid(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Createfunc_opt_itemContext extends ParserRuleContext { + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public Func_asContext func_as() { + return getRuleContext(Func_asContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public Nonreservedword_or_sconstContext nonreservedword_or_sconst() { + return getRuleContext(Nonreservedword_or_sconstContext.class,0); + } + public TerminalNode TRANSFORM() { return getToken(PostgreSqlParser.TRANSFORM, 0); } + public Transform_type_listContext transform_type_list() { + return getRuleContext(Transform_type_listContext.class,0); + } + public TerminalNode WINDOW() { return getToken(PostgreSqlParser.WINDOW, 0); } + public Common_func_opt_itemContext common_func_opt_item() { + return getRuleContext(Common_func_opt_itemContext.class,0); + } + public Createfunc_opt_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createfunc_opt_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatefunc_opt_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatefunc_opt_item(this); + } + } + + public final Createfunc_opt_itemContext createfunc_opt_item() throws RecognitionException { + Createfunc_opt_itemContext _localctx = new Createfunc_opt_itemContext(_ctx, getState()); + enterRule(_localctx, 658, RULE_createfunc_opt_item); + try { + setState(5575); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AS: + enterOuterAlt(_localctx, 1); + { + setState(5567); + match(AS); + setState(5568); + func_as(); + } + break; + case LANGUAGE: + enterOuterAlt(_localctx, 2); + { + setState(5569); + match(LANGUAGE); + setState(5570); + nonreservedword_or_sconst(); + } + break; + case TRANSFORM: + enterOuterAlt(_localctx, 3); + { + setState(5571); + match(TRANSFORM); + setState(5572); + transform_type_list(); + } + break; + case WINDOW: + enterOuterAlt(_localctx, 4); + { + setState(5573); + match(WINDOW); + } + break; + case NOT: + case CALLED: + case COST: + case EXTERNAL: + case IMMUTABLE: + case LEAKPROOF: + case RESET: + case RETURNS: + case ROWS: + case SECURITY: + case SET: + case STABLE: + case STRICT_P: + case VOLATILE: + case SUPPORT: + case PARALLEL: + enterOuterAlt(_localctx, 5); + { + setState(5574); + common_func_opt_item(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_asContext extends ParserRuleContext { + public ParserRuleContext Definition; + public SconstContext def; + public List sconst() { + return getRuleContexts(SconstContext.class); + } + public SconstContext sconst(int i) { + return getRuleContext(SconstContext.class,i); + } + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public Func_asContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_as; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_as(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_as(this); + } + } + + public final Func_asContext func_as() throws RecognitionException { + Func_asContext _localctx = new Func_asContext(_ctx, getState()); + enterRule(_localctx, 660, RULE_func_as); + try { + setState(5582); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,289,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5577); + ((Func_asContext)_localctx).def = sconst(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5578); + sconst(); + setState(5579); + match(COMMA); + setState(5580); + sconst(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Transform_type_listContext extends ParserRuleContext { + public List FOR() { return getTokens(PostgreSqlParser.FOR); } + public TerminalNode FOR(int i) { + return getToken(PostgreSqlParser.FOR, i); + } + public List TYPE_P() { return getTokens(PostgreSqlParser.TYPE_P); } + public TerminalNode TYPE_P(int i) { + return getToken(PostgreSqlParser.TYPE_P, i); + } + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Transform_type_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transform_type_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransform_type_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransform_type_list(this); + } + } + + public final Transform_type_listContext transform_type_list() throws RecognitionException { + Transform_type_listContext _localctx = new Transform_type_listContext(_ctx, getState()); + enterRule(_localctx, 662, RULE_transform_type_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5584); + match(FOR); + setState(5585); + match(TYPE_P); + setState(5586); + typename(); + setState(5593); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5587); + match(COMMA); + setState(5588); + match(FOR); + setState(5589); + match(TYPE_P); + setState(5590); + typename(); + } + } + setState(5595); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_definitionContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public DefinitionContext definition() { + return getRuleContext(DefinitionContext.class,0); + } + public Opt_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_definition(this); + } + } + + public final Opt_definitionContext opt_definition() throws RecognitionException { + Opt_definitionContext _localctx = new Opt_definitionContext(_ctx, getState()); + enterRule(_localctx, 664, RULE_opt_definition); + try { + setState(5599); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,291,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5596); + match(WITH); + setState(5597); + definition(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Table_func_columnContext extends ParserRuleContext { + public Param_nameContext param_name() { + return getRuleContext(Param_nameContext.class,0); + } + public Func_typeContext func_type() { + return getRuleContext(Func_typeContext.class,0); + } + public Table_func_columnContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_table_func_column; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTable_func_column(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTable_func_column(this); + } + } + + public final Table_func_columnContext table_func_column() throws RecognitionException { + Table_func_columnContext _localctx = new Table_func_columnContext(_ctx, getState()); + enterRule(_localctx, 666, RULE_table_func_column); + try { + enterOuterAlt(_localctx, 1); + { + setState(5601); + param_name(); + setState(5602); + func_type(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Table_func_column_listContext extends ParserRuleContext { + public List table_func_column() { + return getRuleContexts(Table_func_columnContext.class); + } + public Table_func_columnContext table_func_column(int i) { + return getRuleContext(Table_func_columnContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Table_func_column_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_table_func_column_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTable_func_column_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTable_func_column_list(this); + } + } + + public final Table_func_column_listContext table_func_column_list() throws RecognitionException { + Table_func_column_listContext _localctx = new Table_func_column_listContext(_ctx, getState()); + enterRule(_localctx, 668, RULE_table_func_column_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5604); + table_func_column(); + setState(5609); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5605); + match(COMMA); + setState(5606); + table_func_column(); + } + } + setState(5611); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterfunctionstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public Alterfunc_opt_listContext alterfunc_opt_list() { + return getRuleContext(Alterfunc_opt_listContext.class,0); + } + public Opt_restrictContext opt_restrict() { + return getRuleContext(Opt_restrictContext.class,0); + } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public AlterfunctionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterfunctionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterfunctionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterfunctionstmt(this); + } + } + + public final AlterfunctionstmtContext alterfunctionstmt() throws RecognitionException { + AlterfunctionstmtContext _localctx = new AlterfunctionstmtContext(_ctx, getState()); + enterRule(_localctx, 670, RULE_alterfunctionstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5612); + match(ALTER); + setState(5613); + _la = _input.LA(1); + if ( !(_la==FUNCTION || _la==PROCEDURE || _la==ROUTINE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(5614); + function_with_argtypes(); + setState(5615); + alterfunc_opt_list(); + setState(5616); + opt_restrict(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Alterfunc_opt_listContext extends ParserRuleContext { + public List common_func_opt_item() { + return getRuleContexts(Common_func_opt_itemContext.class); + } + public Common_func_opt_itemContext common_func_opt_item(int i) { + return getRuleContext(Common_func_opt_itemContext.class,i); + } + public Alterfunc_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterfunc_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterfunc_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterfunc_opt_list(this); + } + } + + public final Alterfunc_opt_listContext alterfunc_opt_list() throws RecognitionException { + Alterfunc_opt_listContext _localctx = new Alterfunc_opt_listContext(_ctx, getState()); + enterRule(_localctx, 672, RULE_alterfunc_opt_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(5619); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(5618); + common_func_opt_item(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(5621); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,293,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_restrictContext extends ParserRuleContext { + public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } + public Opt_restrictContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_restrict; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_restrict(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_restrict(this); + } + } + + public final Opt_restrictContext opt_restrict() throws RecognitionException { + Opt_restrictContext _localctx = new Opt_restrictContext(_ctx, getState()); + enterRule(_localctx, 674, RULE_opt_restrict); + try { + setState(5625); + _errHandler.sync(this); + switch (_input.LA(1)) { + case RESTRICT: + enterOuterAlt(_localctx, 1); + { + setState(5623); + match(RESTRICT); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RemovefuncstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypes_listContext function_with_argtypes_list() { + return getRuleContext(Function_with_argtypes_listContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public RemovefuncstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_removefuncstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRemovefuncstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRemovefuncstmt(this); + } + } + + public final RemovefuncstmtContext removefuncstmt() throws RecognitionException { + RemovefuncstmtContext _localctx = new RemovefuncstmtContext(_ctx, getState()); + enterRule(_localctx, 676, RULE_removefuncstmt); + try { + setState(5663); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5627); + match(DROP); + setState(5628); + match(FUNCTION); + setState(5629); + function_with_argtypes_list(); + setState(5630); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5632); + match(DROP); + setState(5633); + match(FUNCTION); + setState(5634); + match(IF_P); + setState(5635); + match(EXISTS); + setState(5636); + function_with_argtypes_list(); + setState(5637); + opt_drop_behavior(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5639); + match(DROP); + setState(5640); + match(PROCEDURE); + setState(5641); + function_with_argtypes_list(); + setState(5642); + opt_drop_behavior(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5644); + match(DROP); + setState(5645); + match(PROCEDURE); + setState(5646); + match(IF_P); + setState(5647); + match(EXISTS); + setState(5648); + function_with_argtypes_list(); + setState(5649); + opt_drop_behavior(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(5651); + match(DROP); + setState(5652); + match(ROUTINE); + setState(5653); + function_with_argtypes_list(); + setState(5654); + opt_drop_behavior(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(5656); + match(DROP); + setState(5657); + match(ROUTINE); + setState(5658); + match(IF_P); + setState(5659); + match(EXISTS); + setState(5660); + function_with_argtypes_list(); + setState(5661); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RemoveaggrstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public Aggregate_with_argtypes_listContext aggregate_with_argtypes_list() { + return getRuleContext(Aggregate_with_argtypes_listContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public RemoveaggrstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_removeaggrstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRemoveaggrstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRemoveaggrstmt(this); + } + } + + public final RemoveaggrstmtContext removeaggrstmt() throws RecognitionException { + RemoveaggrstmtContext _localctx = new RemoveaggrstmtContext(_ctx, getState()); + enterRule(_localctx, 678, RULE_removeaggrstmt); + try { + setState(5677); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,296,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5665); + match(DROP); + setState(5666); + match(AGGREGATE); + setState(5667); + aggregate_with_argtypes_list(); + setState(5668); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5670); + match(DROP); + setState(5671); + match(AGGREGATE); + setState(5672); + match(IF_P); + setState(5673); + match(EXISTS); + setState(5674); + aggregate_with_argtypes_list(); + setState(5675); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RemoveoperstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public Operator_with_argtypes_listContext operator_with_argtypes_list() { + return getRuleContext(Operator_with_argtypes_listContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public RemoveoperstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_removeoperstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRemoveoperstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRemoveoperstmt(this); + } + } + + public final RemoveoperstmtContext removeoperstmt() throws RecognitionException { + RemoveoperstmtContext _localctx = new RemoveoperstmtContext(_ctx, getState()); + enterRule(_localctx, 680, RULE_removeoperstmt); + try { + setState(5691); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,297,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5679); + match(DROP); + setState(5680); + match(OPERATOR); + setState(5681); + operator_with_argtypes_list(); + setState(5682); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5684); + match(DROP); + setState(5685); + match(OPERATOR); + setState(5686); + match(IF_P); + setState(5687); + match(EXISTS); + setState(5688); + operator_with_argtypes_list(); + setState(5689); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Oper_argtypesContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public TerminalNode NONE() { return getToken(PostgreSqlParser.NONE, 0); } + public Oper_argtypesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_oper_argtypes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOper_argtypes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOper_argtypes(this); + } + } + + public final Oper_argtypesContext oper_argtypes() throws RecognitionException { + Oper_argtypesContext _localctx = new Oper_argtypesContext(_ctx, getState()); + enterRule(_localctx, 682, RULE_oper_argtypes); + try { + setState(5715); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5693); + match(OPEN_PAREN); + setState(5694); + typename(); + setState(5695); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5697); + match(OPEN_PAREN); + setState(5698); + typename(); + setState(5699); + match(COMMA); + setState(5700); + typename(); + setState(5701); + match(CLOSE_PAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5703); + match(OPEN_PAREN); + setState(5704); + match(NONE); + setState(5705); + match(COMMA); + setState(5706); + typename(); + setState(5707); + match(CLOSE_PAREN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5709); + match(OPEN_PAREN); + setState(5710); + typename(); + setState(5711); + match(COMMA); + setState(5712); + match(NONE); + setState(5713); + match(CLOSE_PAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Any_operatorContext extends ParserRuleContext { + public All_opContext all_op() { + return getRuleContext(All_opContext.class,0); + } + public List colid() { + return getRuleContexts(ColidContext.class); + } + public ColidContext colid(int i) { + return getRuleContext(ColidContext.class,i); + } + public List DOT() { return getTokens(PostgreSqlParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(PostgreSqlParser.DOT, i); + } + public Any_operatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_any_operator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAny_operator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAny_operator(this); + } + } + + public final Any_operatorContext any_operator() throws RecognitionException { + Any_operatorContext _localctx = new Any_operatorContext(_ctx, getState()); + enterRule(_localctx, 684, RULE_any_operator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5722); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8610636025129074688L) != 0) || ((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & -113665638399L) != 0) || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & -1L) != 0) || ((((_la - 222)) & ~0x3f) == 0 && ((1L << (_la - 222)) & -9663676417L) != 0) || ((((_la - 286)) & ~0x3f) == 0 && ((1L << (_la - 286)) & -1L) != 0) || ((((_la - 350)) & ~0x3f) == 0 && ((1L << (_la - 350)) & -1L) != 0) || ((((_la - 414)) & ~0x3f) == 0 && ((1L << (_la - 414)) & -1152925902653358081L) != 0) || ((((_la - 478)) & ~0x3f) == 0 && ((1L << (_la - 478)) & -43981136199681L) != 0) || ((((_la - 542)) & ~0x3f) == 0 && ((1L << (_la - 542)) & -1L) != 0) || ((((_la - 606)) & ~0x3f) == 0 && ((1L << (_la - 606)) & 288230685389357055L) != 0)) { + { + { + setState(5717); + colid(); + setState(5718); + match(DOT); + } + } + setState(5724); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5725); + all_op(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Operator_with_argtypes_listContext extends ParserRuleContext { + public List operator_with_argtypes() { + return getRuleContexts(Operator_with_argtypesContext.class); + } + public Operator_with_argtypesContext operator_with_argtypes(int i) { + return getRuleContext(Operator_with_argtypesContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Operator_with_argtypes_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_operator_with_argtypes_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOperator_with_argtypes_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOperator_with_argtypes_list(this); + } + } + + public final Operator_with_argtypes_listContext operator_with_argtypes_list() throws RecognitionException { + Operator_with_argtypes_listContext _localctx = new Operator_with_argtypes_listContext(_ctx, getState()); + enterRule(_localctx, 686, RULE_operator_with_argtypes_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5727); + operator_with_argtypes(); + setState(5732); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5728); + match(COMMA); + setState(5729); + operator_with_argtypes(); + } + } + setState(5734); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Operator_with_argtypesContext extends ParserRuleContext { + public Any_operatorContext any_operator() { + return getRuleContext(Any_operatorContext.class,0); + } + public Oper_argtypesContext oper_argtypes() { + return getRuleContext(Oper_argtypesContext.class,0); + } + public Operator_with_argtypesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_operator_with_argtypes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOperator_with_argtypes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOperator_with_argtypes(this); + } + } + + public final Operator_with_argtypesContext operator_with_argtypes() throws RecognitionException { + Operator_with_argtypesContext _localctx = new Operator_with_argtypesContext(_ctx, getState()); + enterRule(_localctx, 688, RULE_operator_with_argtypes); + try { + enterOuterAlt(_localctx, 1); + { + setState(5735); + any_operator(); + setState(5736); + oper_argtypes(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DostmtContext extends ParserRuleContext { + public TerminalNode DO() { return getToken(PostgreSqlParser.DO, 0); } + public Dostmt_opt_listContext dostmt_opt_list() { + return getRuleContext(Dostmt_opt_listContext.class,0); + } + public DostmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dostmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDostmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDostmt(this); + } + } + + public final DostmtContext dostmt() throws RecognitionException { + DostmtContext _localctx = new DostmtContext(_ctx, getState()); + enterRule(_localctx, 690, RULE_dostmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(5738); + match(DO); + setState(5739); + dostmt_opt_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Dostmt_opt_listContext extends ParserRuleContext { + public List dostmt_opt_item() { + return getRuleContexts(Dostmt_opt_itemContext.class); + } + public Dostmt_opt_itemContext dostmt_opt_item(int i) { + return getRuleContext(Dostmt_opt_itemContext.class,i); + } + public Dostmt_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dostmt_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDostmt_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDostmt_opt_list(this); + } + } + + public final Dostmt_opt_listContext dostmt_opt_list() throws RecognitionException { + Dostmt_opt_listContext _localctx = new Dostmt_opt_listContext(_ctx, getState()); + enterRule(_localctx, 692, RULE_dostmt_opt_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5742); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(5741); + dostmt_opt_item(); + } + } + setState(5744); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==LANGUAGE || ((((_la - 648)) & ~0x3f) == 0 && ((1L << (_la - 648)) & 33554453L) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Dostmt_opt_itemContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public Nonreservedword_or_sconstContext nonreservedword_or_sconst() { + return getRuleContext(Nonreservedword_or_sconstContext.class,0); + } + public Dostmt_opt_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dostmt_opt_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDostmt_opt_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDostmt_opt_item(this); + } + } + + public final Dostmt_opt_itemContext dostmt_opt_item() throws RecognitionException { + Dostmt_opt_itemContext _localctx = new Dostmt_opt_itemContext(_ctx, getState()); + enterRule(_localctx, 694, RULE_dostmt_opt_item); + try { + setState(5749); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(5746); + sconst(); + } + break; + case LANGUAGE: + enterOuterAlt(_localctx, 2); + { + setState(5747); + match(LANGUAGE); + setState(5748); + nonreservedword_or_sconst(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatecaststmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public Cast_contextContext cast_context() { + return getRuleContext(Cast_contextContext.class,0); + } + public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } + public TerminalNode INOUT() { return getToken(PostgreSqlParser.INOUT, 0); } + public CreatecaststmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createcaststmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatecaststmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatecaststmt(this); + } + } + + public final CreatecaststmtContext createcaststmt() throws RecognitionException { + CreatecaststmtContext _localctx = new CreatecaststmtContext(_ctx, getState()); + enterRule(_localctx, 696, RULE_createcaststmt); + try { + setState(5785); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,303,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5751); + match(CREATE); + setState(5752); + match(CAST); + setState(5753); + match(OPEN_PAREN); + setState(5754); + typename(); + setState(5755); + match(AS); + setState(5756); + typename(); + setState(5757); + match(CLOSE_PAREN); + setState(5758); + match(WITH); + setState(5759); + match(FUNCTION); + setState(5760); + function_with_argtypes(); + setState(5761); + cast_context(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5763); + match(CREATE); + setState(5764); + match(CAST); + setState(5765); + match(OPEN_PAREN); + setState(5766); + typename(); + setState(5767); + match(AS); + setState(5768); + typename(); + setState(5769); + match(CLOSE_PAREN); + setState(5770); + match(WITHOUT); + setState(5771); + match(FUNCTION); + setState(5772); + cast_context(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5774); + match(CREATE); + setState(5775); + match(CAST); + setState(5776); + match(OPEN_PAREN); + setState(5777); + typename(); + setState(5778); + match(AS); + setState(5779); + typename(); + setState(5780); + match(CLOSE_PAREN); + setState(5781); + match(WITH); + setState(5782); + match(INOUT); + setState(5783); + cast_context(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cast_contextContext extends ParserRuleContext { + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode IMPLICIT_P() { return getToken(PostgreSqlParser.IMPLICIT_P, 0); } + public TerminalNode ASSIGNMENT() { return getToken(PostgreSqlParser.ASSIGNMENT, 0); } + public Cast_contextContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cast_context; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCast_context(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCast_context(this); + } + } + + public final Cast_contextContext cast_context() throws RecognitionException { + Cast_contextContext _localctx = new Cast_contextContext(_ctx, getState()); + enterRule(_localctx, 698, RULE_cast_context); + try { + setState(5792); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,304,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5787); + match(AS); + setState(5788); + match(IMPLICIT_P); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5789); + match(AS); + setState(5790); + match(ASSIGNMENT); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropcaststmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } + public Opt_if_existsContext opt_if_exists() { + return getRuleContext(Opt_if_existsContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public DropcaststmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropcaststmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDropcaststmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDropcaststmt(this); + } + } + + public final DropcaststmtContext dropcaststmt() throws RecognitionException { + DropcaststmtContext _localctx = new DropcaststmtContext(_ctx, getState()); + enterRule(_localctx, 700, RULE_dropcaststmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(5794); + match(DROP); + setState(5795); + match(CAST); + setState(5796); + opt_if_exists(); + setState(5797); + match(OPEN_PAREN); + setState(5798); + typename(); + setState(5799); + match(AS); + setState(5800); + typename(); + setState(5801); + match(CLOSE_PAREN); + setState(5802); + opt_drop_behavior(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_if_existsContext extends ParserRuleContext { + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public Opt_if_existsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_if_exists; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_if_exists(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_if_exists(this); + } + } + + public final Opt_if_existsContext opt_if_exists() throws RecognitionException { + Opt_if_existsContext _localctx = new Opt_if_existsContext(_ctx, getState()); + enterRule(_localctx, 702, RULE_opt_if_exists); + try { + setState(5807); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IF_P: + enterOuterAlt(_localctx, 1); + { + setState(5804); + match(IF_P); + setState(5805); + match(EXISTS); + } + break; + case OPEN_PAREN: + case FOR: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatetransformstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public Opt_or_replaceContext opt_or_replace() { + return getRuleContext(Opt_or_replaceContext.class,0); + } + public TerminalNode TRANSFORM() { return getToken(PostgreSqlParser.TRANSFORM, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Transform_element_listContext transform_element_list() { + return getRuleContext(Transform_element_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public CreatetransformstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createtransformstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatetransformstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatetransformstmt(this); + } + } + + public final CreatetransformstmtContext createtransformstmt() throws RecognitionException { + CreatetransformstmtContext _localctx = new CreatetransformstmtContext(_ctx, getState()); + enterRule(_localctx, 704, RULE_createtransformstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(5809); + match(CREATE); + setState(5810); + opt_or_replace(); + setState(5811); + match(TRANSFORM); + setState(5812); + match(FOR); + setState(5813); + typename(); + setState(5814); + match(LANGUAGE); + setState(5815); + name(); + setState(5816); + match(OPEN_PAREN); + setState(5817); + transform_element_list(); + setState(5818); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Transform_element_listContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public List SQL_P() { return getTokens(PostgreSqlParser.SQL_P); } + public TerminalNode SQL_P(int i) { + return getToken(PostgreSqlParser.SQL_P, i); + } + public List WITH() { return getTokens(PostgreSqlParser.WITH); } + public TerminalNode WITH(int i) { + return getToken(PostgreSqlParser.WITH, i); + } + public List FUNCTION() { return getTokens(PostgreSqlParser.FUNCTION); } + public TerminalNode FUNCTION(int i) { + return getToken(PostgreSqlParser.FUNCTION, i); + } + public List function_with_argtypes() { + return getRuleContexts(Function_with_argtypesContext.class); + } + public Function_with_argtypesContext function_with_argtypes(int i) { + return getRuleContext(Function_with_argtypesContext.class,i); + } + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Transform_element_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transform_element_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransform_element_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransform_element_list(this); + } + } + + public final Transform_element_listContext transform_element_list() throws RecognitionException { + Transform_element_listContext _localctx = new Transform_element_listContext(_ctx, getState()); + enterRule(_localctx, 706, RULE_transform_element_list); + try { + setState(5854); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,306,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5820); + match(FROM); + setState(5821); + match(SQL_P); + setState(5822); + match(WITH); + setState(5823); + match(FUNCTION); + setState(5824); + function_with_argtypes(); + setState(5825); + match(COMMA); + setState(5826); + match(TO); + setState(5827); + match(SQL_P); + setState(5828); + match(WITH); + setState(5829); + match(FUNCTION); + setState(5830); + function_with_argtypes(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5832); + match(TO); + setState(5833); + match(SQL_P); + setState(5834); + match(WITH); + setState(5835); + match(FUNCTION); + setState(5836); + function_with_argtypes(); + setState(5837); + match(COMMA); + setState(5838); + match(FROM); + setState(5839); + match(SQL_P); + setState(5840); + match(WITH); + setState(5841); + match(FUNCTION); + setState(5842); + function_with_argtypes(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5844); + match(FROM); + setState(5845); + match(SQL_P); + setState(5846); + match(WITH); + setState(5847); + match(FUNCTION); + setState(5848); + function_with_argtypes(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5849); + match(TO); + setState(5850); + match(SQL_P); + setState(5851); + match(WITH); + setState(5852); + match(FUNCTION); + setState(5853); + function_with_argtypes(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DroptransformstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode TRANSFORM() { return getToken(PostgreSqlParser.TRANSFORM, 0); } + public Opt_if_existsContext opt_if_exists() { + return getRuleContext(Opt_if_existsContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public DroptransformstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_droptransformstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDroptransformstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDroptransformstmt(this); + } + } + + public final DroptransformstmtContext droptransformstmt() throws RecognitionException { + DroptransformstmtContext _localctx = new DroptransformstmtContext(_ctx, getState()); + enterRule(_localctx, 708, RULE_droptransformstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(5856); + match(DROP); + setState(5857); + match(TRANSFORM); + setState(5858); + opt_if_exists(); + setState(5859); + match(FOR); + setState(5860); + typename(); + setState(5861); + match(LANGUAGE); + setState(5862); + name(); + setState(5863); + opt_drop_behavior(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReindexstmtContext extends ParserRuleContext { + public TerminalNode REINDEX() { return getToken(PostgreSqlParser.REINDEX, 0); } + public Reindex_target_typeContext reindex_target_type() { + return getRuleContext(Reindex_target_typeContext.class,0); + } + public Opt_concurrentlyContext opt_concurrently() { + return getRuleContext(Opt_concurrentlyContext.class,0); + } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Reindex_target_multitableContext reindex_target_multitable() { + return getRuleContext(Reindex_target_multitableContext.class,0); + } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Reindex_option_listContext reindex_option_list() { + return getRuleContext(Reindex_option_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ReindexstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reindexstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReindexstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReindexstmt(this); + } + } + + public final ReindexstmtContext reindexstmt() throws RecognitionException { + ReindexstmtContext _localctx = new ReindexstmtContext(_ctx, getState()); + enterRule(_localctx, 710, RULE_reindexstmt); + try { + setState(5891); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,307,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5865); + match(REINDEX); + setState(5866); + reindex_target_type(); + setState(5867); + opt_concurrently(); + setState(5868); + qualified_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5870); + match(REINDEX); + setState(5871); + reindex_target_multitable(); + setState(5872); + opt_concurrently(); + setState(5873); + name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5875); + match(REINDEX); + setState(5876); + match(OPEN_PAREN); + setState(5877); + reindex_option_list(); + setState(5878); + match(CLOSE_PAREN); + setState(5879); + reindex_target_type(); + setState(5880); + opt_concurrently(); + setState(5881); + qualified_name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5883); + match(REINDEX); + setState(5884); + match(OPEN_PAREN); + setState(5885); + reindex_option_list(); + setState(5886); + match(CLOSE_PAREN); + setState(5887); + reindex_target_multitable(); + setState(5888); + opt_concurrently(); + setState(5889); + name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Reindex_target_typeContext extends ParserRuleContext { + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public TerminalNode SYSTEM_P() { return getToken(PostgreSqlParser.SYSTEM_P, 0); } + public Reindex_target_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reindex_target_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReindex_target_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReindex_target_type(this); + } + } + + public final Reindex_target_typeContext reindex_target_type() throws RecognitionException { + Reindex_target_typeContext _localctx = new Reindex_target_typeContext(_ctx, getState()); + enterRule(_localctx, 712, RULE_reindex_target_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5893); + _la = _input.LA(1); + if ( !(_la==TABLE || _la==DATABASE || _la==INDEX || _la==SCHEMA || _la==SYSTEM_P) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Reindex_target_multitableContext extends ParserRuleContext { + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode SYSTEM_P() { return getToken(PostgreSqlParser.SYSTEM_P, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public Reindex_target_multitableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reindex_target_multitable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReindex_target_multitable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReindex_target_multitable(this); + } + } + + public final Reindex_target_multitableContext reindex_target_multitable() throws RecognitionException { + Reindex_target_multitableContext _localctx = new Reindex_target_multitableContext(_ctx, getState()); + enterRule(_localctx, 714, RULE_reindex_target_multitable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5895); + _la = _input.LA(1); + if ( !(_la==DATABASE || _la==SCHEMA || _la==SYSTEM_P) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Reindex_option_listContext extends ParserRuleContext { + public List reindex_option_elem() { + return getRuleContexts(Reindex_option_elemContext.class); + } + public Reindex_option_elemContext reindex_option_elem(int i) { + return getRuleContext(Reindex_option_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Reindex_option_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reindex_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReindex_option_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReindex_option_list(this); + } + } + + public final Reindex_option_listContext reindex_option_list() throws RecognitionException { + Reindex_option_listContext _localctx = new Reindex_option_listContext(_ctx, getState()); + enterRule(_localctx, 716, RULE_reindex_option_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5897); + reindex_option_elem(); + setState(5902); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5898); + match(COMMA); + setState(5899); + reindex_option_elem(); + } + } + setState(5904); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Reindex_option_elemContext extends ParserRuleContext { + public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public TerminalNode CONCURRENTLY() { return getToken(PostgreSqlParser.CONCURRENTLY, 0); } + public Reindex_option_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_reindex_option_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReindex_option_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReindex_option_elem(this); + } + } + + public final Reindex_option_elemContext reindex_option_elem() throws RecognitionException { + Reindex_option_elemContext _localctx = new Reindex_option_elemContext(_ctx, getState()); + enterRule(_localctx, 718, RULE_reindex_option_elem); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5905); + _la = _input.LA(1); + if ( !(_la==CONCURRENTLY || _la==VERBOSE || _la==TABLESPACE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltertblspcstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public ReloptionsContext reloptions() { + return getRuleContext(ReloptionsContext.class,0); + } + public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } + public AltertblspcstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altertblspcstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltertblspcstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltertblspcstmt(this); + } + } + + public final AltertblspcstmtContext altertblspcstmt() throws RecognitionException { + AltertblspcstmtContext _localctx = new AltertblspcstmtContext(_ctx, getState()); + enterRule(_localctx, 720, RULE_altertblspcstmt); + try { + setState(5919); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,309,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5907); + match(ALTER); + setState(5908); + match(TABLESPACE); + setState(5909); + name(); + setState(5910); + match(SET); + setState(5911); + reloptions(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5913); + match(ALTER); + setState(5914); + match(TABLESPACE); + setState(5915); + name(); + setState(5916); + match(RESET); + setState(5917); + reloptions(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RenamestmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public Aggregate_with_argtypesContext aggregate_with_argtypes() { + return getRuleContext(Aggregate_with_argtypesContext.class,0); + } + public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); + } + public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode CONVERSION_P() { return getToken(PostgreSqlParser.CONVERSION_P, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public List roleid() { + return getRuleContexts(RoleidContext.class); + } + public RoleidContext roleid(int i) { + return getRuleContext(RoleidContext.class,i); + } + public Opt_proceduralContext opt_procedural() { + return getRuleContext(Opt_proceduralContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public TerminalNode POLICY() { return getToken(PostgreSqlParser.POLICY, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Relation_exprContext relation_expr() { + return getRuleContext(Relation_exprContext.class,0); + } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public Opt_columnContext opt_column() { + return getRuleContext(Opt_columnContext.class,0); + } + public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } + public TerminalNode TEXT_P() { return getToken(PostgreSqlParser.TEXT_P, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode PARSER() { return getToken(PostgreSqlParser.PARSER, 0); } + public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } + public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } + public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TerminalNode ATTRIBUTE() { return getToken(PostgreSqlParser.ATTRIBUTE, 0); } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public RenamestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_renamestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRenamestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRenamestmt(this); + } + } + + public final RenamestmtContext renamestmt() throws RecognitionException { + RenamestmtContext _localctx = new RenamestmtContext(_ctx, getState()); + enterRule(_localctx, 722, RULE_renamestmt); + try { + setState(6389); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,310,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5921); + match(ALTER); + setState(5922); + match(AGGREGATE); + setState(5923); + aggregate_with_argtypes(); + setState(5924); + match(RENAME); + setState(5925); + match(TO); + setState(5926); + name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5928); + match(ALTER); + setState(5929); + match(COLLATION); + setState(5930); + any_name(); + setState(5931); + match(RENAME); + setState(5932); + match(TO); + setState(5933); + name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5935); + match(ALTER); + setState(5936); + match(CONVERSION_P); + setState(5937); + any_name(); + setState(5938); + match(RENAME); + setState(5939); + match(TO); + setState(5940); + name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5942); + match(ALTER); + setState(5943); + match(DATABASE); + setState(5944); + name(); + setState(5945); + match(RENAME); + setState(5946); + match(TO); + setState(5947); + name(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(5949); + match(ALTER); + setState(5950); + match(DOMAIN_P); + setState(5951); + any_name(); + setState(5952); + match(RENAME); + setState(5953); + match(TO); + setState(5954); + name(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(5956); + match(ALTER); + setState(5957); + match(DOMAIN_P); + setState(5958); + any_name(); + setState(5959); + match(RENAME); + setState(5960); + match(CONSTRAINT); + setState(5961); + name(); + setState(5962); + match(TO); + setState(5963); + name(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(5965); + match(ALTER); + setState(5966); + match(FOREIGN); + setState(5967); + match(DATA_P); + setState(5968); + match(WRAPPER); + setState(5969); + name(); + setState(5970); + match(RENAME); + setState(5971); + match(TO); + setState(5972); + name(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(5974); + match(ALTER); + setState(5975); + match(FUNCTION); + setState(5976); + function_with_argtypes(); + setState(5977); + match(RENAME); + setState(5978); + match(TO); + setState(5979); + name(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(5981); + match(ALTER); + setState(5982); + match(GROUP_P); + setState(5983); + roleid(); + setState(5984); + match(RENAME); + setState(5985); + match(TO); + setState(5986); + roleid(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(5988); + match(ALTER); + setState(5989); + opt_procedural(); + setState(5990); + match(LANGUAGE); + setState(5991); + name(); + setState(5992); + match(RENAME); + setState(5993); + match(TO); + setState(5994); + name(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(5996); + match(ALTER); + setState(5997); + match(OPERATOR); + setState(5998); + match(CLASS); + setState(5999); + any_name(); + setState(6000); + match(USING); + setState(6001); + name(); + setState(6002); + match(RENAME); + setState(6003); + match(TO); + setState(6004); + name(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(6006); + match(ALTER); + setState(6007); + match(OPERATOR); + setState(6008); + match(FAMILY); + setState(6009); + any_name(); + setState(6010); + match(USING); + setState(6011); + name(); + setState(6012); + match(RENAME); + setState(6013); + match(TO); + setState(6014); + name(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(6016); + match(ALTER); + setState(6017); + match(POLICY); + setState(6018); + name(); + setState(6019); + match(ON); + setState(6020); + qualified_name(); + setState(6021); + match(RENAME); + setState(6022); + match(TO); + setState(6023); + name(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(6025); + match(ALTER); + setState(6026); + match(POLICY); + setState(6027); + match(IF_P); + setState(6028); + match(EXISTS); + setState(6029); + name(); + setState(6030); + match(ON); + setState(6031); + qualified_name(); + setState(6032); + match(RENAME); + setState(6033); + match(TO); + setState(6034); + name(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(6036); + match(ALTER); + setState(6037); + match(PROCEDURE); + setState(6038); + function_with_argtypes(); + setState(6039); + match(RENAME); + setState(6040); + match(TO); + setState(6041); + name(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(6043); + match(ALTER); + setState(6044); + match(PUBLICATION); + setState(6045); + name(); + setState(6046); + match(RENAME); + setState(6047); + match(TO); + setState(6048); + name(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(6050); + match(ALTER); + setState(6051); + match(ROUTINE); + setState(6052); + function_with_argtypes(); + setState(6053); + match(RENAME); + setState(6054); + match(TO); + setState(6055); + name(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(6057); + match(ALTER); + setState(6058); + match(SCHEMA); + setState(6059); + name(); + setState(6060); + match(RENAME); + setState(6061); + match(TO); + setState(6062); + name(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(6064); + match(ALTER); + setState(6065); + match(SERVER); + setState(6066); + name(); + setState(6067); + match(RENAME); + setState(6068); + match(TO); + setState(6069); + name(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(6071); + match(ALTER); + setState(6072); + match(SUBSCRIPTION); + setState(6073); + name(); + setState(6074); + match(RENAME); + setState(6075); + match(TO); + setState(6076); + name(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(6078); + match(ALTER); + setState(6079); + match(TABLE); + setState(6080); + relation_expr(); + setState(6081); + match(RENAME); + setState(6082); + match(TO); + setState(6083); + name(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(6085); + match(ALTER); + setState(6086); + match(TABLE); + setState(6087); + match(IF_P); + setState(6088); + match(EXISTS); + setState(6089); + relation_expr(); + setState(6090); + match(RENAME); + setState(6091); + match(TO); + setState(6092); + name(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(6094); + match(ALTER); + setState(6095); + match(SEQUENCE); + setState(6096); + qualified_name(); + setState(6097); + match(RENAME); + setState(6098); + match(TO); + setState(6099); + name(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(6101); + match(ALTER); + setState(6102); + match(SEQUENCE); + setState(6103); + match(IF_P); + setState(6104); + match(EXISTS); + setState(6105); + qualified_name(); + setState(6106); + match(RENAME); + setState(6107); + match(TO); + setState(6108); + name(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(6110); + match(ALTER); + setState(6111); + match(VIEW); + setState(6112); + qualified_name(); + setState(6113); + match(RENAME); + setState(6114); + match(TO); + setState(6115); + name(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(6117); + match(ALTER); + setState(6118); + match(VIEW); + setState(6119); + match(IF_P); + setState(6120); + match(EXISTS); + setState(6121); + qualified_name(); + setState(6122); + match(RENAME); + setState(6123); + match(TO); + setState(6124); + name(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(6126); + match(ALTER); + setState(6127); + match(MATERIALIZED); + setState(6128); + match(VIEW); + setState(6129); + qualified_name(); + setState(6130); + match(RENAME); + setState(6131); + match(TO); + setState(6132); + name(); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(6134); + match(ALTER); + setState(6135); + match(MATERIALIZED); + setState(6136); + match(VIEW); + setState(6137); + match(IF_P); + setState(6138); + match(EXISTS); + setState(6139); + qualified_name(); + setState(6140); + match(RENAME); + setState(6141); + match(TO); + setState(6142); + name(); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(6144); + match(ALTER); + setState(6145); + match(INDEX); + setState(6146); + qualified_name(); + setState(6147); + match(RENAME); + setState(6148); + match(TO); + setState(6149); + name(); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(6151); + match(ALTER); + setState(6152); + match(INDEX); + setState(6153); + match(IF_P); + setState(6154); + match(EXISTS); + setState(6155); + qualified_name(); + setState(6156); + match(RENAME); + setState(6157); + match(TO); + setState(6158); + name(); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(6160); + match(ALTER); + setState(6161); + match(FOREIGN); + setState(6162); + match(TABLE); + setState(6163); + relation_expr(); + setState(6164); + match(RENAME); + setState(6165); + match(TO); + setState(6166); + name(); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(6168); + match(ALTER); + setState(6169); + match(FOREIGN); + setState(6170); + match(TABLE); + setState(6171); + match(IF_P); + setState(6172); + match(EXISTS); + setState(6173); + relation_expr(); + setState(6174); + match(RENAME); + setState(6175); + match(TO); + setState(6176); + name(); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(6178); + match(ALTER); + setState(6179); + match(TABLE); + setState(6180); + relation_expr(); + setState(6181); + match(RENAME); + setState(6182); + opt_column(); + setState(6183); + name(); + setState(6184); + match(TO); + setState(6185); + name(); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(6187); + match(ALTER); + setState(6188); + match(TABLE); + setState(6189); + match(IF_P); + setState(6190); + match(EXISTS); + setState(6191); + relation_expr(); + setState(6192); + match(RENAME); + setState(6193); + opt_column(); + setState(6194); + name(); + setState(6195); + match(TO); + setState(6196); + name(); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(6198); + match(ALTER); + setState(6199); + match(VIEW); + setState(6200); + qualified_name(); + setState(6201); + match(RENAME); + setState(6202); + opt_column(); + setState(6203); + name(); + setState(6204); + match(TO); + setState(6205); + name(); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(6207); + match(ALTER); + setState(6208); + match(VIEW); + setState(6209); + match(IF_P); + setState(6210); + match(EXISTS); + setState(6211); + qualified_name(); + setState(6212); + match(RENAME); + setState(6213); + opt_column(); + setState(6214); + name(); + setState(6215); + match(TO); + setState(6216); + name(); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(6218); + match(ALTER); + setState(6219); + match(MATERIALIZED); + setState(6220); + match(VIEW); + setState(6221); + qualified_name(); + setState(6222); + match(RENAME); + setState(6223); + opt_column(); + setState(6224); + name(); + setState(6225); + match(TO); + setState(6226); + name(); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(6228); + match(ALTER); + setState(6229); + match(MATERIALIZED); + setState(6230); + match(VIEW); + setState(6231); + match(IF_P); + setState(6232); + match(EXISTS); + setState(6233); + qualified_name(); + setState(6234); + match(RENAME); + setState(6235); + opt_column(); + setState(6236); + name(); + setState(6237); + match(TO); + setState(6238); + name(); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(6240); + match(ALTER); + setState(6241); + match(TABLE); + setState(6242); + relation_expr(); + setState(6243); + match(RENAME); + setState(6244); + match(CONSTRAINT); + setState(6245); + name(); + setState(6246); + match(TO); + setState(6247); + name(); + } + break; + case 40: + enterOuterAlt(_localctx, 40); + { + setState(6249); + match(ALTER); + setState(6250); + match(TABLE); + setState(6251); + match(IF_P); + setState(6252); + match(EXISTS); + setState(6253); + relation_expr(); + setState(6254); + match(RENAME); + setState(6255); + match(CONSTRAINT); + setState(6256); + name(); + setState(6257); + match(TO); + setState(6258); + name(); + } + break; + case 41: + enterOuterAlt(_localctx, 41); + { + setState(6260); + match(ALTER); + setState(6261); + match(FOREIGN); + setState(6262); + match(TABLE); + setState(6263); + relation_expr(); + setState(6264); + match(RENAME); + setState(6265); + opt_column(); + setState(6266); + name(); + setState(6267); + match(TO); + setState(6268); + name(); + } + break; + case 42: + enterOuterAlt(_localctx, 42); + { + setState(6270); + match(ALTER); + setState(6271); + match(FOREIGN); + setState(6272); + match(TABLE); + setState(6273); + match(IF_P); + setState(6274); + match(EXISTS); + setState(6275); + relation_expr(); + setState(6276); + match(RENAME); + setState(6277); + opt_column(); + setState(6278); + name(); + setState(6279); + match(TO); + setState(6280); + name(); + } + break; + case 43: + enterOuterAlt(_localctx, 43); + { + setState(6282); + match(ALTER); + setState(6283); + match(RULE); + setState(6284); + name(); + setState(6285); + match(ON); + setState(6286); + qualified_name(); + setState(6287); + match(RENAME); + setState(6288); + match(TO); + setState(6289); + name(); + } + break; + case 44: + enterOuterAlt(_localctx, 44); + { + setState(6291); + match(ALTER); + setState(6292); + match(TRIGGER); + setState(6293); + name(); + setState(6294); + match(ON); + setState(6295); + qualified_name(); + setState(6296); + match(RENAME); + setState(6297); + match(TO); + setState(6298); + name(); + } + break; + case 45: + enterOuterAlt(_localctx, 45); + { + setState(6300); + match(ALTER); + setState(6301); + match(EVENT); + setState(6302); + match(TRIGGER); + setState(6303); + name(); + setState(6304); + match(RENAME); + setState(6305); + match(TO); + setState(6306); + name(); + } + break; + case 46: + enterOuterAlt(_localctx, 46); + { + setState(6308); + match(ALTER); + setState(6309); + match(ROLE); + setState(6310); + roleid(); + setState(6311); + match(RENAME); + setState(6312); + match(TO); + setState(6313); + roleid(); + } + break; + case 47: + enterOuterAlt(_localctx, 47); + { + setState(6315); + match(ALTER); + setState(6316); + match(USER); + setState(6317); + roleid(); + setState(6318); + match(RENAME); + setState(6319); + match(TO); + setState(6320); + roleid(); + } + break; + case 48: + enterOuterAlt(_localctx, 48); + { + setState(6322); + match(ALTER); + setState(6323); + match(TABLESPACE); + setState(6324); + name(); + setState(6325); + match(RENAME); + setState(6326); + match(TO); + setState(6327); + name(); + } + break; + case 49: + enterOuterAlt(_localctx, 49); + { + setState(6329); + match(ALTER); + setState(6330); + match(STATISTICS); + setState(6331); + any_name(); + setState(6332); + match(RENAME); + setState(6333); + match(TO); + setState(6334); + name(); + } + break; + case 50: + enterOuterAlt(_localctx, 50); + { + setState(6336); + match(ALTER); + setState(6337); + match(TEXT_P); + setState(6338); + match(SEARCH); + setState(6339); + match(PARSER); + setState(6340); + any_name(); + setState(6341); + match(RENAME); + setState(6342); + match(TO); + setState(6343); + name(); + } + break; + case 51: + enterOuterAlt(_localctx, 51); + { + setState(6345); + match(ALTER); + setState(6346); + match(TEXT_P); + setState(6347); + match(SEARCH); + setState(6348); + match(DICTIONARY); + setState(6349); + any_name(); + setState(6350); + match(RENAME); + setState(6351); + match(TO); + setState(6352); + name(); + } + break; + case 52: + enterOuterAlt(_localctx, 52); + { + setState(6354); + match(ALTER); + setState(6355); + match(TEXT_P); + setState(6356); + match(SEARCH); + setState(6357); + match(TEMPLATE); + setState(6358); + any_name(); + setState(6359); + match(RENAME); + setState(6360); + match(TO); + setState(6361); + name(); + } + break; + case 53: + enterOuterAlt(_localctx, 53); + { + setState(6363); + match(ALTER); + setState(6364); + match(TEXT_P); + setState(6365); + match(SEARCH); + setState(6366); + match(CONFIGURATION); + setState(6367); + any_name(); + setState(6368); + match(RENAME); + setState(6369); + match(TO); + setState(6370); + name(); + } + break; + case 54: + enterOuterAlt(_localctx, 54); + { + setState(6372); + match(ALTER); + setState(6373); + match(TYPE_P); + setState(6374); + any_name(); + setState(6375); + match(RENAME); + setState(6376); + match(TO); + setState(6377); + name(); + } + break; + case 55: + enterOuterAlt(_localctx, 55); + { + setState(6379); + match(ALTER); + setState(6380); + match(TYPE_P); + setState(6381); + any_name(); + setState(6382); + match(RENAME); + setState(6383); + match(ATTRIBUTE); + setState(6384); + name(); + setState(6385); + match(TO); + setState(6386); + name(); + setState(6387); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_columnContext extends ParserRuleContext { + public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } + public Opt_columnContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_column; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_column(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_column(this); + } + } + + public final Opt_columnContext opt_column() throws RecognitionException { + Opt_columnContext _localctx = new Opt_columnContext(_ctx, getState()); + enterRule(_localctx, 724, RULE_opt_column); + try { + setState(6393); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,311,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6391); + match(COLUMN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_set_dataContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public Opt_set_dataContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_set_data; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_set_data(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_set_data(this); + } + } + + public final Opt_set_dataContext opt_set_data() throws RecognitionException { + Opt_set_dataContext _localctx = new Opt_set_dataContext(_ctx, getState()); + enterRule(_localctx, 726, RULE_opt_set_data); + try { + setState(6398); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SET: + enterOuterAlt(_localctx, 1); + { + setState(6395); + match(SET); + setState(6396); + match(DATA_P); + } + break; + case TYPE_P: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterobjectdependsstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public Opt_noContext opt_no() { + return getRuleContext(Opt_noContext.class,0); + } + public TerminalNode DEPENDS() { return getToken(PostgreSqlParser.DEPENDS, 0); } + public List ON() { return getTokens(PostgreSqlParser.ON); } + public TerminalNode ON(int i) { + return getToken(PostgreSqlParser.ON, i); + } + public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); + } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public AlterobjectdependsstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterobjectdependsstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterobjectdependsstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterobjectdependsstmt(this); + } + } + + public final AlterobjectdependsstmtContext alterobjectdependsstmt() throws RecognitionException { + AlterobjectdependsstmtContext _localctx = new AlterobjectdependsstmtContext(_ctx, getState()); + enterRule(_localctx, 728, RULE_alterobjectdependsstmt); + try { + setState(6457); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,313,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6400); + match(ALTER); + setState(6401); + match(FUNCTION); + setState(6402); + function_with_argtypes(); + setState(6403); + opt_no(); + setState(6404); + match(DEPENDS); + setState(6405); + match(ON); + setState(6406); + match(EXTENSION); + setState(6407); + name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6409); + match(ALTER); + setState(6410); + match(PROCEDURE); + setState(6411); + function_with_argtypes(); + setState(6412); + opt_no(); + setState(6413); + match(DEPENDS); + setState(6414); + match(ON); + setState(6415); + match(EXTENSION); + setState(6416); + name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6418); + match(ALTER); + setState(6419); + match(ROUTINE); + setState(6420); + function_with_argtypes(); + setState(6421); + opt_no(); + setState(6422); + match(DEPENDS); + setState(6423); + match(ON); + setState(6424); + match(EXTENSION); + setState(6425); + name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6427); + match(ALTER); + setState(6428); + match(TRIGGER); + setState(6429); + name(); + setState(6430); + match(ON); + setState(6431); + qualified_name(); + setState(6432); + opt_no(); + setState(6433); + match(DEPENDS); + setState(6434); + match(ON); + setState(6435); + match(EXTENSION); + setState(6436); + name(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(6438); + match(ALTER); + setState(6439); + match(MATERIALIZED); + setState(6440); + match(VIEW); + setState(6441); + qualified_name(); + setState(6442); + opt_no(); + setState(6443); + match(DEPENDS); + setState(6444); + match(ON); + setState(6445); + match(EXTENSION); + setState(6446); + name(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(6448); + match(ALTER); + setState(6449); + match(INDEX); + setState(6450); + qualified_name(); + setState(6451); + opt_no(); + setState(6452); + match(DEPENDS); + setState(6453); + match(ON); + setState(6454); + match(EXTENSION); + setState(6455); + name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_noContext extends ParserRuleContext { + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public Opt_noContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_no; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_no(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_no(this); + } + } + + public final Opt_noContext opt_no() throws RecognitionException { + Opt_noContext _localctx = new Opt_noContext(_ctx, getState()); + enterRule(_localctx, 730, RULE_opt_no); + try { + setState(6461); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NO: + enterOuterAlt(_localctx, 1); + { + setState(6459); + match(NO); + } + break; + case DEPENDS: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterobjectschemastmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public Aggregate_with_argtypesContext aggregate_with_argtypes() { + return getRuleContext(Aggregate_with_argtypesContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); + } + public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode CONVERSION_P() { return getToken(PostgreSqlParser.CONVERSION_P, 0); } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public Operator_with_argtypesContext operator_with_argtypes() { + return getRuleContext(Operator_with_argtypesContext.class,0); + } + public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Relation_exprContext relation_expr() { + return getRuleContext(Relation_exprContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } + public TerminalNode TEXT_P() { return getToken(PostgreSqlParser.TEXT_P, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode PARSER() { return getToken(PostgreSqlParser.PARSER, 0); } + public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } + public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } + public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public AlterobjectschemastmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterobjectschemastmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterobjectschemastmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterobjectschemastmt(this); + } + } + + public final AlterobjectschemastmtContext alterobjectschemastmt() throws RecognitionException { + AlterobjectschemastmtContext _localctx = new AlterobjectschemastmtContext(_ctx, getState()); + enterRule(_localctx, 732, RULE_alterobjectschemastmt); + try { + setState(6680); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,315,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6463); + match(ALTER); + setState(6464); + match(AGGREGATE); + setState(6465); + aggregate_with_argtypes(); + setState(6466); + match(SET); + setState(6467); + match(SCHEMA); + setState(6468); + name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6470); + match(ALTER); + setState(6471); + match(COLLATION); + setState(6472); + any_name(); + setState(6473); + match(SET); + setState(6474); + match(SCHEMA); + setState(6475); + name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6477); + match(ALTER); + setState(6478); + match(CONVERSION_P); + setState(6479); + any_name(); + setState(6480); + match(SET); + setState(6481); + match(SCHEMA); + setState(6482); + name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6484); + match(ALTER); + setState(6485); + match(DOMAIN_P); + setState(6486); + any_name(); + setState(6487); + match(SET); + setState(6488); + match(SCHEMA); + setState(6489); + name(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(6491); + match(ALTER); + setState(6492); + match(EXTENSION); + setState(6493); + name(); + setState(6494); + match(SET); + setState(6495); + match(SCHEMA); + setState(6496); + name(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(6498); + match(ALTER); + setState(6499); + match(FUNCTION); + setState(6500); + function_with_argtypes(); + setState(6501); + match(SET); + setState(6502); + match(SCHEMA); + setState(6503); + name(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(6505); + match(ALTER); + setState(6506); + match(OPERATOR); + setState(6507); + operator_with_argtypes(); + setState(6508); + match(SET); + setState(6509); + match(SCHEMA); + setState(6510); + name(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(6512); + match(ALTER); + setState(6513); + match(OPERATOR); + setState(6514); + match(CLASS); + setState(6515); + any_name(); + setState(6516); + match(USING); + setState(6517); + name(); + setState(6518); + match(SET); + setState(6519); + match(SCHEMA); + setState(6520); + name(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(6522); + match(ALTER); + setState(6523); + match(OPERATOR); + setState(6524); + match(FAMILY); + setState(6525); + any_name(); + setState(6526); + match(USING); + setState(6527); + name(); + setState(6528); + match(SET); + setState(6529); + match(SCHEMA); + setState(6530); + name(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(6532); + match(ALTER); + setState(6533); + match(PROCEDURE); + setState(6534); + function_with_argtypes(); + setState(6535); + match(SET); + setState(6536); + match(SCHEMA); + setState(6537); + name(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(6539); + match(ALTER); + setState(6540); + match(ROUTINE); + setState(6541); + function_with_argtypes(); + setState(6542); + match(SET); + setState(6543); + match(SCHEMA); + setState(6544); + name(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(6546); + match(ALTER); + setState(6547); + match(TABLE); + setState(6548); + relation_expr(); + setState(6549); + match(SET); + setState(6550); + match(SCHEMA); + setState(6551); + name(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(6553); + match(ALTER); + setState(6554); + match(TABLE); + setState(6555); + match(IF_P); + setState(6556); + match(EXISTS); + setState(6557); + relation_expr(); + setState(6558); + match(SET); + setState(6559); + match(SCHEMA); + setState(6560); + name(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(6562); + match(ALTER); + setState(6563); + match(STATISTICS); + setState(6564); + any_name(); + setState(6565); + match(SET); + setState(6566); + match(SCHEMA); + setState(6567); + name(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(6569); + match(ALTER); + setState(6570); + match(TEXT_P); + setState(6571); + match(SEARCH); + setState(6572); + match(PARSER); + setState(6573); + any_name(); + setState(6574); + match(SET); + setState(6575); + match(SCHEMA); + setState(6576); + name(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(6578); + match(ALTER); + setState(6579); + match(TEXT_P); + setState(6580); + match(SEARCH); + setState(6581); + match(DICTIONARY); + setState(6582); + any_name(); + setState(6583); + match(SET); + setState(6584); + match(SCHEMA); + setState(6585); + name(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(6587); + match(ALTER); + setState(6588); + match(TEXT_P); + setState(6589); + match(SEARCH); + setState(6590); + match(TEMPLATE); + setState(6591); + any_name(); + setState(6592); + match(SET); + setState(6593); + match(SCHEMA); + setState(6594); + name(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(6596); + match(ALTER); + setState(6597); + match(TEXT_P); + setState(6598); + match(SEARCH); + setState(6599); + match(CONFIGURATION); + setState(6600); + any_name(); + setState(6601); + match(SET); + setState(6602); + match(SCHEMA); + setState(6603); + name(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(6605); + match(ALTER); + setState(6606); + match(SEQUENCE); + setState(6607); + qualified_name(); + setState(6608); + match(SET); + setState(6609); + match(SCHEMA); + setState(6610); + name(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(6612); + match(ALTER); + setState(6613); + match(SEQUENCE); + setState(6614); + match(IF_P); + setState(6615); + match(EXISTS); + setState(6616); + qualified_name(); + setState(6617); + match(SET); + setState(6618); + match(SCHEMA); + setState(6619); + name(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(6621); + match(ALTER); + setState(6622); + match(VIEW); + setState(6623); + qualified_name(); + setState(6624); + match(SET); + setState(6625); + match(SCHEMA); + setState(6626); + name(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(6628); + match(ALTER); + setState(6629); + match(VIEW); + setState(6630); + match(IF_P); + setState(6631); + match(EXISTS); + setState(6632); + qualified_name(); + setState(6633); + match(SET); + setState(6634); + match(SCHEMA); + setState(6635); + name(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(6637); + match(ALTER); + setState(6638); + match(MATERIALIZED); + setState(6639); + match(VIEW); + setState(6640); + qualified_name(); + setState(6641); + match(SET); + setState(6642); + match(SCHEMA); + setState(6643); + name(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(6645); + match(ALTER); + setState(6646); + match(MATERIALIZED); + setState(6647); + match(VIEW); + setState(6648); + match(IF_P); + setState(6649); + match(EXISTS); + setState(6650); + qualified_name(); + setState(6651); + match(SET); + setState(6652); + match(SCHEMA); + setState(6653); + name(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(6655); + match(ALTER); + setState(6656); + match(FOREIGN); + setState(6657); + match(TABLE); + setState(6658); + relation_expr(); + setState(6659); + match(SET); + setState(6660); + match(SCHEMA); + setState(6661); + name(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(6663); + match(ALTER); + setState(6664); + match(FOREIGN); + setState(6665); + match(TABLE); + setState(6666); + match(IF_P); + setState(6667); + match(EXISTS); + setState(6668); + relation_expr(); + setState(6669); + match(SET); + setState(6670); + match(SCHEMA); + setState(6671); + name(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(6673); + match(ALTER); + setState(6674); + match(TYPE_P); + setState(6675); + any_name(); + setState(6676); + match(SET); + setState(6677); + match(SCHEMA); + setState(6678); + name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlteroperatorstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public Operator_with_argtypesContext operator_with_argtypes() { + return getRuleContext(Operator_with_argtypesContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Operator_def_listContext operator_def_list() { + return getRuleContext(Operator_def_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public AlteroperatorstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alteroperatorstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlteroperatorstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlteroperatorstmt(this); + } + } + + public final AlteroperatorstmtContext alteroperatorstmt() throws RecognitionException { + AlteroperatorstmtContext _localctx = new AlteroperatorstmtContext(_ctx, getState()); + enterRule(_localctx, 734, RULE_alteroperatorstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(6682); + match(ALTER); + setState(6683); + match(OPERATOR); + setState(6684); + operator_with_argtypes(); + setState(6685); + match(SET); + setState(6686); + match(OPEN_PAREN); + setState(6687); + operator_def_list(); + setState(6688); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Operator_def_listContext extends ParserRuleContext { + public List operator_def_elem() { + return getRuleContexts(Operator_def_elemContext.class); + } + public Operator_def_elemContext operator_def_elem(int i) { + return getRuleContext(Operator_def_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Operator_def_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_operator_def_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOperator_def_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOperator_def_list(this); + } + } + + public final Operator_def_listContext operator_def_list() throws RecognitionException { + Operator_def_listContext _localctx = new Operator_def_listContext(_ctx, getState()); + enterRule(_localctx, 736, RULE_operator_def_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6690); + operator_def_elem(); + setState(6695); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6691); + match(COMMA); + setState(6692); + operator_def_elem(); + } + } + setState(6697); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Operator_def_elemContext extends ParserRuleContext { + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public TerminalNode NONE() { return getToken(PostgreSqlParser.NONE, 0); } + public Operator_def_argContext operator_def_arg() { + return getRuleContext(Operator_def_argContext.class,0); + } + public Operator_def_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_operator_def_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOperator_def_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOperator_def_elem(this); + } + } + + public final Operator_def_elemContext operator_def_elem() throws RecognitionException { + Operator_def_elemContext _localctx = new Operator_def_elemContext(_ctx, getState()); + enterRule(_localctx, 738, RULE_operator_def_elem); + try { + setState(6706); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,317,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6698); + collabel(); + setState(6699); + match(EQUAL); + setState(6700); + match(NONE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6702); + collabel(); + setState(6703); + match(EQUAL); + setState(6704); + operator_def_arg(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Operator_def_argContext extends ParserRuleContext { + public Func_typeContext func_type() { + return getRuleContext(Func_typeContext.class,0); + } + public Reserved_keywordContext reserved_keyword() { + return getRuleContext(Reserved_keywordContext.class,0); + } + public Qual_all_opContext qual_all_op() { + return getRuleContext(Qual_all_opContext.class,0); + } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Operator_def_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_operator_def_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOperator_def_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOperator_def_arg(this); + } + } + + public final Operator_def_argContext operator_def_arg() throws RecognitionException { + Operator_def_argContext _localctx = new Operator_def_argContext(_ctx, getState()); + enterRule(_localctx, 740, RULE_operator_def_arg); + try { + setState(6713); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,318,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6708); + func_type(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6709); + reserved_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6710); + qual_all_op(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6711); + numericonly(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(6712); + sconst(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltertypestmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Operator_def_listContext operator_def_list() { + return getRuleContext(Operator_def_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public AltertypestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altertypestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltertypestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltertypestmt(this); + } + } + + public final AltertypestmtContext altertypestmt() throws RecognitionException { + AltertypestmtContext _localctx = new AltertypestmtContext(_ctx, getState()); + enterRule(_localctx, 742, RULE_altertypestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(6715); + match(ALTER); + setState(6716); + match(TYPE_P); + setState(6717); + any_name(); + setState(6718); + match(SET); + setState(6719); + match(OPEN_PAREN); + setState(6720); + operator_def_list(); + setState(6721); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterownerstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public Aggregate_with_argtypesContext aggregate_with_argtypes() { + return getRuleContext(Aggregate_with_argtypesContext.class,0); + } + public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode CONVERSION_P() { return getToken(PostgreSqlParser.CONVERSION_P, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public Function_with_argtypesContext function_with_argtypes() { + return getRuleContext(Function_with_argtypesContext.class,0); + } + public Opt_proceduralContext opt_procedural() { + return getRuleContext(Opt_proceduralContext.class,0); + } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public TerminalNode LARGE_P() { return getToken(PostgreSqlParser.LARGE_P, 0); } + public TerminalNode OBJECT_P() { return getToken(PostgreSqlParser.OBJECT_P, 0); } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public Operator_with_argtypesContext operator_with_argtypes() { + return getRuleContext(Operator_with_argtypesContext.class,0); + } + public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } + public TerminalNode TEXT_P() { return getToken(PostgreSqlParser.TEXT_P, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } + public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } + public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } + public AlterownerstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterownerstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterownerstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterownerstmt(this); + } + } + + public final AlterownerstmtContext alterownerstmt() throws RecognitionException { + AlterownerstmtContext _localctx = new AlterownerstmtContext(_ctx, getState()); + enterRule(_localctx, 744, RULE_alterownerstmt); + try { + setState(6906); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,319,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6723); + match(ALTER); + setState(6724); + match(AGGREGATE); + setState(6725); + aggregate_with_argtypes(); + setState(6726); + match(OWNER); + setState(6727); + match(TO); + setState(6728); + rolespec(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6730); + match(ALTER); + setState(6731); + match(COLLATION); + setState(6732); + any_name(); + setState(6733); + match(OWNER); + setState(6734); + match(TO); + setState(6735); + rolespec(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6737); + match(ALTER); + setState(6738); + match(CONVERSION_P); + setState(6739); + any_name(); + setState(6740); + match(OWNER); + setState(6741); + match(TO); + setState(6742); + rolespec(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6744); + match(ALTER); + setState(6745); + match(DATABASE); + setState(6746); + name(); + setState(6747); + match(OWNER); + setState(6748); + match(TO); + setState(6749); + rolespec(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(6751); + match(ALTER); + setState(6752); + match(DOMAIN_P); + setState(6753); + any_name(); + setState(6754); + match(OWNER); + setState(6755); + match(TO); + setState(6756); + rolespec(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(6758); + match(ALTER); + setState(6759); + match(FUNCTION); + setState(6760); + function_with_argtypes(); + setState(6761); + match(OWNER); + setState(6762); + match(TO); + setState(6763); + rolespec(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(6765); + match(ALTER); + setState(6766); + opt_procedural(); + setState(6767); + match(LANGUAGE); + setState(6768); + name(); + setState(6769); + match(OWNER); + setState(6770); + match(TO); + setState(6771); + rolespec(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(6773); + match(ALTER); + setState(6774); + match(LARGE_P); + setState(6775); + match(OBJECT_P); + setState(6776); + numericonly(); + setState(6777); + match(OWNER); + setState(6778); + match(TO); + setState(6779); + rolespec(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(6781); + match(ALTER); + setState(6782); + match(OPERATOR); + setState(6783); + operator_with_argtypes(); + setState(6784); + match(OWNER); + setState(6785); + match(TO); + setState(6786); + rolespec(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(6788); + match(ALTER); + setState(6789); + match(OPERATOR); + setState(6790); + match(CLASS); + setState(6791); + any_name(); + setState(6792); + match(USING); + setState(6793); + name(); + setState(6794); + match(OWNER); + setState(6795); + match(TO); + setState(6796); + rolespec(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(6798); + match(ALTER); + setState(6799); + match(OPERATOR); + setState(6800); + match(FAMILY); + setState(6801); + any_name(); + setState(6802); + match(USING); + setState(6803); + name(); + setState(6804); + match(OWNER); + setState(6805); + match(TO); + setState(6806); + rolespec(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(6808); + match(ALTER); + setState(6809); + match(PROCEDURE); + setState(6810); + function_with_argtypes(); + setState(6811); + match(OWNER); + setState(6812); + match(TO); + setState(6813); + rolespec(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(6815); + match(ALTER); + setState(6816); + match(ROUTINE); + setState(6817); + function_with_argtypes(); + setState(6818); + match(OWNER); + setState(6819); + match(TO); + setState(6820); + rolespec(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(6822); + match(ALTER); + setState(6823); + match(SCHEMA); + setState(6824); + name(); + setState(6825); + match(OWNER); + setState(6826); + match(TO); + setState(6827); + rolespec(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(6829); + match(ALTER); + setState(6830); + match(TYPE_P); + setState(6831); + any_name(); + setState(6832); + match(OWNER); + setState(6833); + match(TO); + setState(6834); + rolespec(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(6836); + match(ALTER); + setState(6837); + match(TABLESPACE); + setState(6838); + name(); + setState(6839); + match(OWNER); + setState(6840); + match(TO); + setState(6841); + rolespec(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(6843); + match(ALTER); + setState(6844); + match(STATISTICS); + setState(6845); + any_name(); + setState(6846); + match(OWNER); + setState(6847); + match(TO); + setState(6848); + rolespec(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(6850); + match(ALTER); + setState(6851); + match(TEXT_P); + setState(6852); + match(SEARCH); + setState(6853); + match(DICTIONARY); + setState(6854); + any_name(); + setState(6855); + match(OWNER); + setState(6856); + match(TO); + setState(6857); + rolespec(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(6859); + match(ALTER); + setState(6860); + match(TEXT_P); + setState(6861); + match(SEARCH); + setState(6862); + match(CONFIGURATION); + setState(6863); + any_name(); + setState(6864); + match(OWNER); + setState(6865); + match(TO); + setState(6866); + rolespec(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(6868); + match(ALTER); + setState(6869); + match(FOREIGN); + setState(6870); + match(DATA_P); + setState(6871); + match(WRAPPER); + setState(6872); + name(); + setState(6873); + match(OWNER); + setState(6874); + match(TO); + setState(6875); + rolespec(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(6877); + match(ALTER); + setState(6878); + match(SERVER); + setState(6879); + name(); + setState(6880); + match(OWNER); + setState(6881); + match(TO); + setState(6882); + rolespec(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(6884); + match(ALTER); + setState(6885); + match(EVENT); + setState(6886); + match(TRIGGER); + setState(6887); + name(); + setState(6888); + match(OWNER); + setState(6889); + match(TO); + setState(6890); + rolespec(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(6892); + match(ALTER); + setState(6893); + match(PUBLICATION); + setState(6894); + name(); + setState(6895); + match(OWNER); + setState(6896); + match(TO); + setState(6897); + rolespec(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(6899); + match(ALTER); + setState(6900); + match(SUBSCRIPTION); + setState(6901); + name(); + setState(6902); + match(OWNER); + setState(6903); + match(TO); + setState(6904); + rolespec(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatepublicationstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_publication_for_tablesContext opt_publication_for_tables() { + return getRuleContext(Opt_publication_for_tablesContext.class,0); + } + public Opt_definitionContext opt_definition() { + return getRuleContext(Opt_definitionContext.class,0); + } + public CreatepublicationstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createpublicationstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatepublicationstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatepublicationstmt(this); + } + } + + public final CreatepublicationstmtContext createpublicationstmt() throws RecognitionException { + CreatepublicationstmtContext _localctx = new CreatepublicationstmtContext(_ctx, getState()); + enterRule(_localctx, 746, RULE_createpublicationstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(6908); + match(CREATE); + setState(6909); + match(PUBLICATION); + setState(6910); + name(); + setState(6911); + opt_publication_for_tables(); + setState(6912); + opt_definition(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_publication_for_tablesContext extends ParserRuleContext { + public Publication_for_tablesContext publication_for_tables() { + return getRuleContext(Publication_for_tablesContext.class,0); + } + public Opt_publication_for_tablesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_publication_for_tables; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_publication_for_tables(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_publication_for_tables(this); + } + } + + public final Opt_publication_for_tablesContext opt_publication_for_tables() throws RecognitionException { + Opt_publication_for_tablesContext _localctx = new Opt_publication_for_tablesContext(_ctx, getState()); + enterRule(_localctx, 748, RULE_opt_publication_for_tables); + try { + setState(6916); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(6914); + publication_for_tables(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Publication_for_tablesContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Relation_expr_listContext relation_expr_list() { + return getRuleContext(Relation_expr_listContext.class,0); + } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode TABLES() { return getToken(PostgreSqlParser.TABLES, 0); } + public Publication_for_tablesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_publication_for_tables; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPublication_for_tables(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPublication_for_tables(this); + } + } + + public final Publication_for_tablesContext publication_for_tables() throws RecognitionException { + Publication_for_tablesContext _localctx = new Publication_for_tablesContext(_ctx, getState()); + enterRule(_localctx, 750, RULE_publication_for_tables); + try { + setState(6924); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,321,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6918); + match(FOR); + setState(6919); + match(TABLE); + setState(6920); + relation_expr_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6921); + match(FOR); + setState(6922); + match(ALL); + setState(6923); + match(TABLES); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterpublicationstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public DefinitionContext definition() { + return getRuleContext(DefinitionContext.class,0); + } + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Relation_expr_listContext relation_expr_list() { + return getRuleContext(Relation_expr_listContext.class,0); + } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public AlterpublicationstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterpublicationstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterpublicationstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterpublicationstmt(this); + } + } + + public final AlterpublicationstmtContext alterpublicationstmt() throws RecognitionException { + AlterpublicationstmtContext _localctx = new AlterpublicationstmtContext(_ctx, getState()); + enterRule(_localctx, 752, RULE_alterpublicationstmt); + try { + setState(6953); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,322,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6926); + match(ALTER); + setState(6927); + match(PUBLICATION); + setState(6928); + name(); + setState(6929); + match(SET); + setState(6930); + definition(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6932); + match(ALTER); + setState(6933); + match(PUBLICATION); + setState(6934); + name(); + setState(6935); + match(ADD_P); + setState(6936); + match(TABLE); + setState(6937); + relation_expr_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6939); + match(ALTER); + setState(6940); + match(PUBLICATION); + setState(6941); + name(); + setState(6942); + match(SET); + setState(6943); + match(TABLE); + setState(6944); + relation_expr_list(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6946); + match(ALTER); + setState(6947); + match(PUBLICATION); + setState(6948); + name(); + setState(6949); + match(DROP); + setState(6950); + match(TABLE); + setState(6951); + relation_expr_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatesubscriptionstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } + public Publication_name_listContext publication_name_list() { + return getRuleContext(Publication_name_listContext.class,0); + } + public Opt_definitionContext opt_definition() { + return getRuleContext(Opt_definitionContext.class,0); + } + public CreatesubscriptionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createsubscriptionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatesubscriptionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatesubscriptionstmt(this); + } + } + + public final CreatesubscriptionstmtContext createsubscriptionstmt() throws RecognitionException { + CreatesubscriptionstmtContext _localctx = new CreatesubscriptionstmtContext(_ctx, getState()); + enterRule(_localctx, 754, RULE_createsubscriptionstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(6955); + match(CREATE); + setState(6956); + match(SUBSCRIPTION); + setState(6957); + name(); + setState(6958); + match(CONNECTION); + setState(6959); + sconst(); + setState(6960); + match(PUBLICATION); + setState(6961); + publication_name_list(); + setState(6962); + opt_definition(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Publication_name_listContext extends ParserRuleContext { + public List publication_name_item() { + return getRuleContexts(Publication_name_itemContext.class); + } + public Publication_name_itemContext publication_name_item(int i) { + return getRuleContext(Publication_name_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Publication_name_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_publication_name_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPublication_name_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPublication_name_list(this); + } + } + + public final Publication_name_listContext publication_name_list() throws RecognitionException { + Publication_name_listContext _localctx = new Publication_name_listContext(_ctx, getState()); + enterRule(_localctx, 756, RULE_publication_name_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(6964); + publication_name_item(); + setState(6969); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(6965); + match(COMMA); + setState(6966); + publication_name_item(); + } + } + setState(6971); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Publication_name_itemContext extends ParserRuleContext { + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public Publication_name_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_publication_name_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPublication_name_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPublication_name_item(this); + } + } + + public final Publication_name_itemContext publication_name_item() throws RecognitionException { + Publication_name_itemContext _localctx = new Publication_name_itemContext(_ctx, getState()); + enterRule(_localctx, 758, RULE_publication_name_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(6972); + collabel(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltersubscriptionstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public DefinitionContext definition() { + return getRuleContext(DefinitionContext.class,0); + } + public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode REFRESH() { return getToken(PostgreSqlParser.REFRESH, 0); } + public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } + public Opt_definitionContext opt_definition() { + return getRuleContext(Opt_definitionContext.class,0); + } + public Publication_name_listContext publication_name_list() { + return getRuleContext(Publication_name_listContext.class,0); + } + public TerminalNode ENABLE_P() { return getToken(PostgreSqlParser.ENABLE_P, 0); } + public TerminalNode DISABLE_P() { return getToken(PostgreSqlParser.DISABLE_P, 0); } + public AltersubscriptionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altersubscriptionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltersubscriptionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltersubscriptionstmt(this); + } + } + + public final AltersubscriptionstmtContext altersubscriptionstmt() throws RecognitionException { + AltersubscriptionstmtContext _localctx = new AltersubscriptionstmtContext(_ctx, getState()); + enterRule(_localctx, 760, RULE_altersubscriptionstmt); + try { + setState(7011); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,324,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(6974); + match(ALTER); + setState(6975); + match(SUBSCRIPTION); + setState(6976); + name(); + setState(6977); + match(SET); + setState(6978); + definition(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(6980); + match(ALTER); + setState(6981); + match(SUBSCRIPTION); + setState(6982); + name(); + setState(6983); + match(CONNECTION); + setState(6984); + sconst(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(6986); + match(ALTER); + setState(6987); + match(SUBSCRIPTION); + setState(6988); + name(); + setState(6989); + match(REFRESH); + setState(6990); + match(PUBLICATION); + setState(6991); + opt_definition(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(6993); + match(ALTER); + setState(6994); + match(SUBSCRIPTION); + setState(6995); + name(); + setState(6996); + match(SET); + setState(6997); + match(PUBLICATION); + setState(6998); + publication_name_list(); + setState(6999); + opt_definition(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(7001); + match(ALTER); + setState(7002); + match(SUBSCRIPTION); + setState(7003); + name(); + setState(7004); + match(ENABLE_P); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(7006); + match(ALTER); + setState(7007); + match(SUBSCRIPTION); + setState(7008); + name(); + setState(7009); + match(DISABLE_P); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropsubscriptionstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public DropsubscriptionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropsubscriptionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDropsubscriptionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDropsubscriptionstmt(this); + } + } + + public final DropsubscriptionstmtContext dropsubscriptionstmt() throws RecognitionException { + DropsubscriptionstmtContext _localctx = new DropsubscriptionstmtContext(_ctx, getState()); + enterRule(_localctx, 762, RULE_dropsubscriptionstmt); + try { + setState(7025); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,325,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7013); + match(DROP); + setState(7014); + match(SUBSCRIPTION); + setState(7015); + name(); + setState(7016); + opt_drop_behavior(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7018); + match(DROP); + setState(7019); + match(SUBSCRIPTION); + setState(7020); + match(IF_P); + setState(7021); + match(EXISTS); + setState(7022); + name(); + setState(7023); + opt_drop_behavior(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RulestmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public Opt_or_replaceContext opt_or_replace() { + return getRuleContext(Opt_or_replaceContext.class,0); + } + public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public EventContext event() { + return getRuleContext(EventContext.class,0); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class,0); + } + public TerminalNode DO() { return getToken(PostgreSqlParser.DO, 0); } + public Opt_insteadContext opt_instead() { + return getRuleContext(Opt_insteadContext.class,0); + } + public RuleactionlistContext ruleactionlist() { + return getRuleContext(RuleactionlistContext.class,0); + } + public RulestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rulestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRulestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRulestmt(this); + } + } + + public final RulestmtContext rulestmt() throws RecognitionException { + RulestmtContext _localctx = new RulestmtContext(_ctx, getState()); + enterRule(_localctx, 764, RULE_rulestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7027); + match(CREATE); + setState(7028); + opt_or_replace(); + setState(7029); + match(RULE); + setState(7030); + name(); + setState(7031); + match(AS); + setState(7032); + match(ON); + setState(7033); + event(); + setState(7034); + match(TO); + setState(7035); + qualified_name(); + setState(7036); + where_clause(); + setState(7037); + match(DO); + setState(7038); + opt_instead(); + setState(7039); + ruleactionlist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RuleactionlistContext extends ParserRuleContext { + public TerminalNode NOTHING() { return getToken(PostgreSqlParser.NOTHING, 0); } + public RuleactionstmtContext ruleactionstmt() { + return getRuleContext(RuleactionstmtContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public RuleactionmultiContext ruleactionmulti() { + return getRuleContext(RuleactionmultiContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public RuleactionlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ruleactionlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRuleactionlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRuleactionlist(this); + } + } + + public final RuleactionlistContext ruleactionlist() throws RecognitionException { + RuleactionlistContext _localctx = new RuleactionlistContext(_ctx, getState()); + enterRule(_localctx, 766, RULE_ruleactionlist); + try { + setState(7047); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,326,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7041); + match(NOTHING); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7042); + ruleactionstmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7043); + match(OPEN_PAREN); + setState(7044); + ruleactionmulti(); + setState(7045); + match(CLOSE_PAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RuleactionmultiContext extends ParserRuleContext { + public List ruleactionstmtOrEmpty() { + return getRuleContexts(RuleactionstmtOrEmptyContext.class); + } + public RuleactionstmtOrEmptyContext ruleactionstmtOrEmpty(int i) { + return getRuleContext(RuleactionstmtOrEmptyContext.class,i); + } + public List SEMI() { return getTokens(PostgreSqlParser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(PostgreSqlParser.SEMI, i); + } + public RuleactionmultiContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ruleactionmulti; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRuleactionmulti(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRuleactionmulti(this); + } + } + + public final RuleactionmultiContext ruleactionmulti() throws RecognitionException { + RuleactionmultiContext _localctx = new RuleactionmultiContext(_ctx, getState()); + enterRule(_localctx, 768, RULE_ruleactionmulti); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7049); + ruleactionstmtOrEmpty(); + setState(7054); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==SEMI) { + { + { + setState(7050); + match(SEMI); + setState(7051); + ruleactionstmtOrEmpty(); + } + } + setState(7056); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RuleactionstmtContext extends ParserRuleContext { + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public InsertstmtContext insertstmt() { + return getRuleContext(InsertstmtContext.class,0); + } + public UpdatestmtContext updatestmt() { + return getRuleContext(UpdatestmtContext.class,0); + } + public DeletestmtContext deletestmt() { + return getRuleContext(DeletestmtContext.class,0); + } + public NotifystmtContext notifystmt() { + return getRuleContext(NotifystmtContext.class,0); + } + public RuleactionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ruleactionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRuleactionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRuleactionstmt(this); + } + } + + public final RuleactionstmtContext ruleactionstmt() throws RecognitionException { + RuleactionstmtContext _localctx = new RuleactionstmtContext(_ctx, getState()); + enterRule(_localctx, 770, RULE_ruleactionstmt); + try { + setState(7062); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,328,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7057); + selectstmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7058); + insertstmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7059); + updatestmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7060); + deletestmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(7061); + notifystmt(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RuleactionstmtOrEmptyContext extends ParserRuleContext { + public RuleactionstmtContext ruleactionstmt() { + return getRuleContext(RuleactionstmtContext.class,0); + } + public RuleactionstmtOrEmptyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ruleactionstmtOrEmpty; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRuleactionstmtOrEmpty(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRuleactionstmtOrEmpty(this); + } + } + + public final RuleactionstmtOrEmptyContext ruleactionstmtOrEmpty() throws RecognitionException { + RuleactionstmtOrEmptyContext _localctx = new RuleactionstmtOrEmptyContext(_ctx, getState()); + enterRule(_localctx, 772, RULE_ruleactionstmtOrEmpty); + try { + setState(7066); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case SELECT: + case TABLE: + case WITH: + case DELETE_P: + case INSERT: + case NOTIFY: + case UPDATE: + case VALUES: + enterOuterAlt(_localctx, 1); + { + setState(7064); + ruleactionstmt(); + } + break; + case CLOSE_PAREN: + case SEMI: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EventContext extends ParserRuleContext { + public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public TerminalNode DELETE_P() { return getToken(PostgreSqlParser.DELETE_P, 0); } + public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } + public EventContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_event; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterEvent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitEvent(this); + } + } + + public final EventContext event() throws RecognitionException { + EventContext _localctx = new EventContext(_ctx, getState()); + enterRule(_localctx, 774, RULE_event); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7068); + _la = _input.LA(1); + if ( !(_la==SELECT || _la==DELETE_P || _la==INSERT || _la==UPDATE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_insteadContext extends ParserRuleContext { + public TerminalNode INSTEAD() { return getToken(PostgreSqlParser.INSTEAD, 0); } + public TerminalNode ALSO() { return getToken(PostgreSqlParser.ALSO, 0); } + public Opt_insteadContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_instead; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_instead(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_instead(this); + } + } + + public final Opt_insteadContext opt_instead() throws RecognitionException { + Opt_insteadContext _localctx = new Opt_insteadContext(_ctx, getState()); + enterRule(_localctx, 776, RULE_opt_instead); + try { + setState(7073); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INSTEAD: + enterOuterAlt(_localctx, 1); + { + setState(7070); + match(INSTEAD); + } + break; + case ALSO: + enterOuterAlt(_localctx, 2); + { + setState(7071); + match(ALSO); + } + break; + case OPEN_PAREN: + case SELECT: + case TABLE: + case WITH: + case DELETE_P: + case INSERT: + case NOTHING: + case NOTIFY: + case UPDATE: + case VALUES: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NotifystmtContext extends ParserRuleContext { + public TerminalNode NOTIFY() { return getToken(PostgreSqlParser.NOTIFY, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Notify_payloadContext notify_payload() { + return getRuleContext(Notify_payloadContext.class,0); + } + public NotifystmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_notifystmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNotifystmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNotifystmt(this); + } + } + + public final NotifystmtContext notifystmt() throws RecognitionException { + NotifystmtContext _localctx = new NotifystmtContext(_ctx, getState()); + enterRule(_localctx, 778, RULE_notifystmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7075); + match(NOTIFY); + setState(7076); + colid(); + setState(7077); + notify_payload(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Notify_payloadContext extends ParserRuleContext { + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Notify_payloadContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_notify_payload; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNotify_payload(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNotify_payload(this); + } + } + + public final Notify_payloadContext notify_payload() throws RecognitionException { + Notify_payloadContext _localctx = new Notify_payloadContext(_ctx, getState()); + enterRule(_localctx, 780, RULE_notify_payload); + try { + setState(7082); + _errHandler.sync(this); + switch (_input.LA(1)) { + case COMMA: + enterOuterAlt(_localctx, 1); + { + setState(7079); + match(COMMA); + setState(7080); + sconst(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ListenstmtContext extends ParserRuleContext { + public TerminalNode LISTEN() { return getToken(PostgreSqlParser.LISTEN, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public ListenstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_listenstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterListenstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitListenstmt(this); + } + } + + public final ListenstmtContext listenstmt() throws RecognitionException { + ListenstmtContext _localctx = new ListenstmtContext(_ctx, getState()); + enterRule(_localctx, 782, RULE_listenstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7084); + match(LISTEN); + setState(7085); + colid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UnlistenstmtContext extends ParserRuleContext { + public TerminalNode UNLISTEN() { return getToken(PostgreSqlParser.UNLISTEN, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public UnlistenstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unlistenstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUnlistenstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUnlistenstmt(this); + } + } + + public final UnlistenstmtContext unlistenstmt() throws RecognitionException { + UnlistenstmtContext _localctx = new UnlistenstmtContext(_ctx, getState()); + enterRule(_localctx, 784, RULE_unlistenstmt); + try { + setState(7091); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,332,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7087); + match(UNLISTEN); + setState(7088); + colid(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7089); + match(UNLISTEN); + setState(7090); + match(STAR); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TransactionstmtContext extends ParserRuleContext { + public TerminalNode ABORT_P() { return getToken(PostgreSqlParser.ABORT_P, 0); } + public Opt_transactionContext opt_transaction() { + return getRuleContext(Opt_transactionContext.class,0); + } + public Opt_transaction_chainContext opt_transaction_chain() { + return getRuleContext(Opt_transaction_chainContext.class,0); + } + public TerminalNode BEGIN_P() { return getToken(PostgreSqlParser.BEGIN_P, 0); } + public Transaction_mode_list_or_emptyContext transaction_mode_list_or_empty() { + return getRuleContext(Transaction_mode_list_or_emptyContext.class,0); + } + public TerminalNode START() { return getToken(PostgreSqlParser.START, 0); } + public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } + public TerminalNode COMMIT() { return getToken(PostgreSqlParser.COMMIT, 0); } + public TerminalNode END_P() { return getToken(PostgreSqlParser.END_P, 0); } + public TerminalNode ROLLBACK() { return getToken(PostgreSqlParser.ROLLBACK, 0); } + public TerminalNode SAVEPOINT() { return getToken(PostgreSqlParser.SAVEPOINT, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode RELEASE() { return getToken(PostgreSqlParser.RELEASE, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public TerminalNode PREPARE() { return getToken(PostgreSqlParser.PREPARE, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public TerminalNode PREPARED() { return getToken(PostgreSqlParser.PREPARED, 0); } + public TransactionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transactionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransactionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransactionstmt(this); + } + } + + public final TransactionstmtContext transactionstmt() throws RecognitionException { + TransactionstmtContext _localctx = new TransactionstmtContext(_ctx, getState()); + enterRule(_localctx, 786, RULE_transactionstmt); + try { + setState(7143); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,333,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7093); + match(ABORT_P); + setState(7094); + opt_transaction(); + setState(7095); + opt_transaction_chain(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7097); + match(BEGIN_P); + setState(7098); + opt_transaction(); + setState(7099); + transaction_mode_list_or_empty(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7101); + match(START); + setState(7102); + match(TRANSACTION); + setState(7103); + transaction_mode_list_or_empty(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7104); + match(COMMIT); + setState(7105); + opt_transaction(); + setState(7106); + opt_transaction_chain(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(7108); + match(END_P); + setState(7109); + opt_transaction(); + setState(7110); + opt_transaction_chain(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(7112); + match(ROLLBACK); + setState(7113); + opt_transaction(); + setState(7114); + opt_transaction_chain(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(7116); + match(SAVEPOINT); + setState(7117); + colid(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(7118); + match(RELEASE); + setState(7119); + match(SAVEPOINT); + setState(7120); + colid(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(7121); + match(RELEASE); + setState(7122); + colid(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(7123); + match(ROLLBACK); + setState(7124); + opt_transaction(); + setState(7125); + match(TO); + setState(7126); + match(SAVEPOINT); + setState(7127); + colid(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(7129); + match(ROLLBACK); + setState(7130); + opt_transaction(); + setState(7131); + match(TO); + setState(7132); + colid(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(7134); + match(PREPARE); + setState(7135); + match(TRANSACTION); + setState(7136); + sconst(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(7137); + match(COMMIT); + setState(7138); + match(PREPARED); + setState(7139); + sconst(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(7140); + match(ROLLBACK); + setState(7141); + match(PREPARED); + setState(7142); + sconst(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_transactionContext extends ParserRuleContext { + public TerminalNode WORK() { return getToken(PostgreSqlParser.WORK, 0); } + public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } + public Opt_transactionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_transaction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_transaction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_transaction(this); + } + } + + public final Opt_transactionContext opt_transaction() throws RecognitionException { + Opt_transactionContext _localctx = new Opt_transactionContext(_ctx, getState()); + enterRule(_localctx, 788, RULE_opt_transaction); + try { + setState(7148); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WORK: + enterOuterAlt(_localctx, 1); + { + setState(7145); + match(WORK); + } + break; + case TRANSACTION: + enterOuterAlt(_localctx, 2); + { + setState(7146); + match(TRANSACTION); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case AND: + case CREATE: + case DEFERRABLE: + case DO: + case FETCH: + case GRANT: + case INTO: + case NOT: + case SELECT: + case TABLE: + case TO: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case ISOLATION: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case READ: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Transaction_mode_itemContext extends ParserRuleContext { + public TerminalNode ISOLATION() { return getToken(PostgreSqlParser.ISOLATION, 0); } + public TerminalNode LEVEL() { return getToken(PostgreSqlParser.LEVEL, 0); } + public Iso_levelContext iso_level() { + return getRuleContext(Iso_levelContext.class,0); + } + public TerminalNode READ() { return getToken(PostgreSqlParser.READ, 0); } + public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } + public TerminalNode WRITE() { return getToken(PostgreSqlParser.WRITE, 0); } + public TerminalNode DEFERRABLE() { return getToken(PostgreSqlParser.DEFERRABLE, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public Transaction_mode_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transaction_mode_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransaction_mode_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransaction_mode_item(this); + } + } + + public final Transaction_mode_itemContext transaction_mode_item() throws RecognitionException { + Transaction_mode_itemContext _localctx = new Transaction_mode_itemContext(_ctx, getState()); + enterRule(_localctx, 790, RULE_transaction_mode_item); + try { + setState(7160); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,335,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7150); + match(ISOLATION); + setState(7151); + match(LEVEL); + setState(7152); + iso_level(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7153); + match(READ); + setState(7154); + match(ONLY); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7155); + match(READ); + setState(7156); + match(WRITE); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7157); + match(DEFERRABLE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(7158); + match(NOT); + setState(7159); + match(DEFERRABLE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Transaction_mode_listContext extends ParserRuleContext { + public List transaction_mode_item() { + return getRuleContexts(Transaction_mode_itemContext.class); + } + public Transaction_mode_itemContext transaction_mode_item(int i) { + return getRuleContext(Transaction_mode_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Transaction_mode_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transaction_mode_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransaction_mode_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransaction_mode_list(this); + } + } + + public final Transaction_mode_listContext transaction_mode_list() throws RecognitionException { + Transaction_mode_listContext _localctx = new Transaction_mode_listContext(_ctx, getState()); + enterRule(_localctx, 792, RULE_transaction_mode_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7162); + transaction_mode_item(); + setState(7169); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA || _la==DEFERRABLE || _la==NOT || _la==ISOLATION || _la==READ) { + { + { + setState(7164); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(7163); + match(COMMA); + } + } + + setState(7166); + transaction_mode_item(); + } + } + setState(7171); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Transaction_mode_list_or_emptyContext extends ParserRuleContext { + public Transaction_mode_listContext transaction_mode_list() { + return getRuleContext(Transaction_mode_listContext.class,0); + } + public Transaction_mode_list_or_emptyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_transaction_mode_list_or_empty; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTransaction_mode_list_or_empty(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTransaction_mode_list_or_empty(this); + } + } + + public final Transaction_mode_list_or_emptyContext transaction_mode_list_or_empty() throws RecognitionException { + Transaction_mode_list_or_emptyContext _localctx = new Transaction_mode_list_or_emptyContext(_ctx, getState()); + enterRule(_localctx, 794, RULE_transaction_mode_list_or_empty); + try { + setState(7174); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEFERRABLE: + case NOT: + case ISOLATION: + case READ: + enterOuterAlt(_localctx, 1); + { + setState(7172); + transaction_mode_list(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_transaction_chainContext extends ParserRuleContext { + public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } + public TerminalNode CHAIN() { return getToken(PostgreSqlParser.CHAIN, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public Opt_transaction_chainContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_transaction_chain; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_transaction_chain(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_transaction_chain(this); + } + } + + public final Opt_transaction_chainContext opt_transaction_chain() throws RecognitionException { + Opt_transaction_chainContext _localctx = new Opt_transaction_chainContext(_ctx, getState()); + enterRule(_localctx, 796, RULE_opt_transaction_chain); + int _la; + try { + setState(7182); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + enterOuterAlt(_localctx, 1); + { + setState(7176); + match(AND); + setState(7178); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(7177); + match(NO); + } + } + + setState(7180); + match(CHAIN); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ViewstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public OpttempContext opttemp() { + return getRuleContext(OpttempContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public Opt_check_optionContext opt_check_option() { + return getRuleContext(Opt_check_optionContext.class,0); + } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Opt_column_listContext opt_column_list() { + return getRuleContext(Opt_column_listContext.class,0); + } + public Opt_reloptionsContext opt_reloptions() { + return getRuleContext(Opt_reloptionsContext.class,0); + } + public TerminalNode RECURSIVE() { return getToken(PostgreSqlParser.RECURSIVE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public ColumnlistContext columnlist() { + return getRuleContext(ColumnlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } + public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } + public ViewstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_viewstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterViewstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitViewstmt(this); + } + } + + public final ViewstmtContext viewstmt() throws RecognitionException { + ViewstmtContext _localctx = new ViewstmtContext(_ctx, getState()); + enterRule(_localctx, 798, RULE_viewstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7184); + match(CREATE); + setState(7187); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OR) { + { + setState(7185); + match(OR); + setState(7186); + match(REPLACE); + } + } + + setState(7189); + opttemp(); + setState(7203); + _errHandler.sync(this); + switch (_input.LA(1)) { + case VIEW: + { + setState(7190); + match(VIEW); + setState(7191); + qualified_name(); + setState(7192); + opt_column_list(); + setState(7193); + opt_reloptions(); + } + break; + case RECURSIVE: + { + setState(7195); + match(RECURSIVE); + setState(7196); + match(VIEW); + setState(7197); + qualified_name(); + setState(7198); + match(OPEN_PAREN); + setState(7199); + columnlist(); + setState(7200); + match(CLOSE_PAREN); + setState(7201); + opt_reloptions(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(7205); + match(AS); + setState(7206); + selectstmt(); + setState(7207); + opt_check_option(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_check_optionContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public TerminalNode CASCADED() { return getToken(PostgreSqlParser.CASCADED, 0); } + public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } + public Opt_check_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_check_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_check_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_check_option(this); + } + } + + public final Opt_check_optionContext opt_check_option() throws RecognitionException { + Opt_check_optionContext _localctx = new Opt_check_optionContext(_ctx, getState()); + enterRule(_localctx, 800, RULE_opt_check_option); + int _la; + try { + setState(7216); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,344,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7209); + match(WITH); + setState(7211); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADED || _la==LOCAL) { + { + setState(7210); + _la = _input.LA(1); + if ( !(_la==CASCADED || _la==LOCAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(7213); + match(CHECK); + setState(7214); + match(OPTION); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LoadstmtContext extends ParserRuleContext { + public TerminalNode LOAD() { return getToken(PostgreSqlParser.LOAD, 0); } + public File_nameContext file_name() { + return getRuleContext(File_nameContext.class,0); + } + public LoadstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_loadstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLoadstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLoadstmt(this); + } + } + + public final LoadstmtContext loadstmt() throws RecognitionException { + LoadstmtContext _localctx = new LoadstmtContext(_ctx, getState()); + enterRule(_localctx, 802, RULE_loadstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7218); + match(LOAD); + setState(7219); + file_name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatedbstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public Createdb_opt_listContext createdb_opt_list() { + return getRuleContext(Createdb_opt_listContext.class,0); + } + public CreatedbstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createdbstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatedbstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatedbstmt(this); + } + } + + public final CreatedbstmtContext createdbstmt() throws RecognitionException { + CreatedbstmtContext _localctx = new CreatedbstmtContext(_ctx, getState()); + enterRule(_localctx, 804, RULE_createdbstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7221); + match(CREATE); + setState(7222); + match(DATABASE); + setState(7223); + name(); + setState(7224); + opt_with(); + setState(7225); + createdb_opt_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Createdb_opt_listContext extends ParserRuleContext { + public Createdb_opt_itemsContext createdb_opt_items() { + return getRuleContext(Createdb_opt_itemsContext.class,0); + } + public Createdb_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createdb_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatedb_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatedb_opt_list(this); + } + } + + public final Createdb_opt_listContext createdb_opt_list() throws RecognitionException { + Createdb_opt_listContext _localctx = new Createdb_opt_listContext(_ctx, getState()); + enterRule(_localctx, 806, RULE_createdb_opt_list); + try { + setState(7229); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,345,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7227); + createdb_opt_items(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Createdb_opt_itemsContext extends ParserRuleContext { + public List createdb_opt_item() { + return getRuleContexts(Createdb_opt_itemContext.class); + } + public Createdb_opt_itemContext createdb_opt_item(int i) { + return getRuleContext(Createdb_opt_itemContext.class,i); + } + public Createdb_opt_itemsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createdb_opt_items; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatedb_opt_items(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatedb_opt_items(this); + } + } + + public final Createdb_opt_itemsContext createdb_opt_items() throws RecognitionException { + Createdb_opt_itemsContext _localctx = new Createdb_opt_itemsContext(_ctx, getState()); + enterRule(_localctx, 808, RULE_createdb_opt_items); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(7232); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(7231); + createdb_opt_item(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(7234); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,346,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Createdb_opt_itemContext extends ParserRuleContext { + public Createdb_opt_nameContext createdb_opt_name() { + return getRuleContext(Createdb_opt_nameContext.class,0); + } + public Opt_equalContext opt_equal() { + return getRuleContext(Opt_equalContext.class,0); + } + public SignediconstContext signediconst() { + return getRuleContext(SignediconstContext.class,0); + } + public Opt_boolean_or_stringContext opt_boolean_or_string() { + return getRuleContext(Opt_boolean_or_stringContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public Createdb_opt_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createdb_opt_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatedb_opt_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatedb_opt_item(this); + } + } + + public final Createdb_opt_itemContext createdb_opt_item() throws RecognitionException { + Createdb_opt_itemContext _localctx = new Createdb_opt_itemContext(_ctx, getState()); + enterRule(_localctx, 810, RULE_createdb_opt_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(7236); + createdb_opt_name(); + setState(7237); + opt_equal(); + setState(7241); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,347,_ctx) ) { + case 1: + { + setState(7238); + signediconst(); + } + break; + case 2: + { + setState(7239); + opt_boolean_or_string(); + } + break; + case 3: + { + setState(7240); + match(DEFAULT); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Createdb_opt_nameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } + public TerminalNode LIMIT() { return getToken(PostgreSqlParser.LIMIT, 0); } + public TerminalNode ENCODING() { return getToken(PostgreSqlParser.ENCODING, 0); } + public TerminalNode LOCATION() { return getToken(PostgreSqlParser.LOCATION, 0); } + public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } + public Createdb_opt_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createdb_opt_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatedb_opt_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatedb_opt_name(this); + } + } + + public final Createdb_opt_nameContext createdb_opt_name() throws RecognitionException { + Createdb_opt_nameContext _localctx = new Createdb_opt_nameContext(_ctx, getState()); + enterRule(_localctx, 812, RULE_createdb_opt_name); + try { + setState(7251); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case OUTER_P: + case ABSOLUTE_P: + case BACKWARD: + case CHAIN: + case CLOSE: + case COMMIT: + case CONTINUE_P: + case CURSOR: + case FIRST_P: + case FORWARD: + case INSERT: + case LAST_P: + case MOVE: + case NEXT: + case NO: + case OPTION: + case PRIOR: + case RELATIVE_P: + case RESET: + case ROLLBACK: + case SCHEMA: + case SCROLL: + case SET: + case TYPE_P: + case CALL: + case CURRENT_P: + case ROWTYPE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(7243); + identifier(); + } + break; + case CONNECTION: + enterOuterAlt(_localctx, 2); + { + setState(7244); + match(CONNECTION); + setState(7245); + match(LIMIT); + } + break; + case ENCODING: + enterOuterAlt(_localctx, 3); + { + setState(7246); + match(ENCODING); + } + break; + case LOCATION: + enterOuterAlt(_localctx, 4); + { + setState(7247); + match(LOCATION); + } + break; + case OWNER: + enterOuterAlt(_localctx, 5); + { + setState(7248); + match(OWNER); + } + break; + case TABLESPACE: + enterOuterAlt(_localctx, 6); + { + setState(7249); + match(TABLESPACE); + } + break; + case TEMPLATE: + enterOuterAlt(_localctx, 7); + { + setState(7250); + match(TEMPLATE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_equalContext extends ParserRuleContext { + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public Opt_equalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_equal; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_equal(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_equal(this); + } + } + + public final Opt_equalContext opt_equal() throws RecognitionException { + Opt_equalContext _localctx = new Opt_equalContext(_ctx, getState()); + enterRule(_localctx, 814, RULE_opt_equal); + try { + setState(7255); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EQUAL: + enterOuterAlt(_localctx, 1); + { + setState(7253); + match(EQUAL); + } + break; + case PLUS: + case MINUS: + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case ON: + case TABLE: + case TRUE_P: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case Integral: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterdatabasestmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); + } + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public Createdb_opt_listContext createdb_opt_list() { + return getRuleContext(Createdb_opt_listContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public AlterdatabasestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterdatabasestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterdatabasestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterdatabasestmt(this); + } + } + + public final AlterdatabasestmtContext alterdatabasestmt() throws RecognitionException { + AlterdatabasestmtContext _localctx = new AlterdatabasestmtContext(_ctx, getState()); + enterRule(_localctx, 816, RULE_alterdatabasestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7257); + match(ALTER); + setState(7258); + match(DATABASE); + setState(7259); + name(); + setState(7266); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,350,_ctx) ) { + case 1: + { + setState(7260); + match(WITH); + setState(7261); + createdb_opt_list(); + } + break; + case 2: + { + setState(7262); + createdb_opt_list(); + } + break; + case 3: + { + setState(7263); + match(SET); + setState(7264); + match(TABLESPACE); + setState(7265); + name(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterdatabasesetstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public SetresetclauseContext setresetclause() { + return getRuleContext(SetresetclauseContext.class,0); + } + public AlterdatabasesetstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterdatabasesetstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterdatabasesetstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterdatabasesetstmt(this); + } + } + + public final AlterdatabasesetstmtContext alterdatabasesetstmt() throws RecognitionException { + AlterdatabasesetstmtContext _localctx = new AlterdatabasesetstmtContext(_ctx, getState()); + enterRule(_localctx, 818, RULE_alterdatabasesetstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7268); + match(ALTER); + setState(7269); + match(DATABASE); + setState(7270); + name(); + setState(7271); + setresetclause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DropdbstmtContext extends ParserRuleContext { + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public Opt_withContext opt_with() { + return getRuleContext(Opt_withContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Drop_option_listContext drop_option_list() { + return getRuleContext(Drop_option_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public DropdbstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dropdbstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDropdbstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDropdbstmt(this); + } + } + + public final DropdbstmtContext dropdbstmt() throws RecognitionException { + DropdbstmtContext _localctx = new DropdbstmtContext(_ctx, getState()); + enterRule(_localctx, 820, RULE_dropdbstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7273); + match(DROP); + setState(7274); + match(DATABASE); + setState(7277); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,351,_ctx) ) { + case 1: + { + setState(7275); + match(IF_P); + setState(7276); + match(EXISTS); + } + break; + } + setState(7279); + name(); + setState(7285); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,352,_ctx) ) { + case 1: + { + setState(7280); + opt_with(); + setState(7281); + match(OPEN_PAREN); + setState(7282); + drop_option_list(); + setState(7283); + match(CLOSE_PAREN); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Drop_option_listContext extends ParserRuleContext { + public List drop_option() { + return getRuleContexts(Drop_optionContext.class); + } + public Drop_optionContext drop_option(int i) { + return getRuleContext(Drop_optionContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Drop_option_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_drop_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_option_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_option_list(this); + } + } + + public final Drop_option_listContext drop_option_list() throws RecognitionException { + Drop_option_listContext _localctx = new Drop_option_listContext(_ctx, getState()); + enterRule(_localctx, 822, RULE_drop_option_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7287); + drop_option(); + setState(7292); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7288); + match(COMMA); + setState(7289); + drop_option(); + } + } + setState(7294); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Drop_optionContext extends ParserRuleContext { + public TerminalNode FORCE() { return getToken(PostgreSqlParser.FORCE, 0); } + public Drop_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_drop_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_option(this); + } + } + + public final Drop_optionContext drop_option() throws RecognitionException { + Drop_optionContext _localctx = new Drop_optionContext(_ctx, getState()); + enterRule(_localctx, 824, RULE_drop_option); + try { + enterOuterAlt(_localctx, 1); + { + setState(7295); + match(FORCE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltercollationstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode REFRESH() { return getToken(PostgreSqlParser.REFRESH, 0); } + public TerminalNode VERSION_P() { return getToken(PostgreSqlParser.VERSION_P, 0); } + public AltercollationstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altercollationstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltercollationstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltercollationstmt(this); + } + } + + public final AltercollationstmtContext altercollationstmt() throws RecognitionException { + AltercollationstmtContext _localctx = new AltercollationstmtContext(_ctx, getState()); + enterRule(_localctx, 826, RULE_altercollationstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7297); + match(ALTER); + setState(7298); + match(COLLATION); + setState(7299); + any_name(); + setState(7300); + match(REFRESH); + setState(7301); + match(VERSION_P); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltersystemstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode SYSTEM_P() { return getToken(PostgreSqlParser.SYSTEM_P, 0); } + public Generic_setContext generic_set() { + return getRuleContext(Generic_setContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } + public AltersystemstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altersystemstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltersystemstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltersystemstmt(this); + } + } + + public final AltersystemstmtContext altersystemstmt() throws RecognitionException { + AltersystemstmtContext _localctx = new AltersystemstmtContext(_ctx, getState()); + enterRule(_localctx, 828, RULE_altersystemstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7303); + match(ALTER); + setState(7304); + match(SYSTEM_P); + setState(7305); + _la = _input.LA(1); + if ( !(_la==RESET || _la==SET) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7306); + generic_set(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreatedomainstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Opt_asContext opt_as() { + return getRuleContext(Opt_asContext.class,0); + } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public ColquallistContext colquallist() { + return getRuleContext(ColquallistContext.class,0); + } + public CreatedomainstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createdomainstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreatedomainstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreatedomainstmt(this); + } + } + + public final CreatedomainstmtContext createdomainstmt() throws RecognitionException { + CreatedomainstmtContext _localctx = new CreatedomainstmtContext(_ctx, getState()); + enterRule(_localctx, 830, RULE_createdomainstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7308); + match(CREATE); + setState(7309); + match(DOMAIN_P); + setState(7310); + any_name(); + setState(7311); + opt_as(); + setState(7312); + typename(); + setState(7313); + colquallist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AlterdomainstmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Alter_column_defaultContext alter_column_default() { + return getRuleContext(Alter_column_defaultContext.class,0); + } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public TableconstraintContext tableconstraint() { + return getRuleContext(TableconstraintContext.class,0); + } + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_drop_behaviorContext opt_drop_behavior() { + return getRuleContext(Opt_drop_behaviorContext.class,0); + } + public TerminalNode VALIDATE() { return getToken(PostgreSqlParser.VALIDATE, 0); } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public AlterdomainstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alterdomainstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlterdomainstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlterdomainstmt(this); + } + } + + public final AlterdomainstmtContext alterdomainstmt() throws RecognitionException { + AlterdomainstmtContext _localctx = new AlterdomainstmtContext(_ctx, getState()); + enterRule(_localctx, 832, RULE_alterdomainstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7315); + match(ALTER); + setState(7316); + match(DOMAIN_P); + setState(7317); + any_name(); + setState(7339); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,355,_ctx) ) { + case 1: + { + setState(7318); + alter_column_default(); + } + break; + case 2: + { + setState(7319); + match(DROP); + setState(7320); + match(NOT); + setState(7321); + match(NULL_P); + } + break; + case 3: + { + setState(7322); + match(SET); + setState(7323); + match(NOT); + setState(7324); + match(NULL_P); + } + break; + case 4: + { + setState(7325); + match(ADD_P); + setState(7326); + tableconstraint(); + } + break; + case 5: + { + setState(7327); + match(DROP); + setState(7328); + match(CONSTRAINT); + setState(7331); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,354,_ctx) ) { + case 1: + { + setState(7329); + match(IF_P); + setState(7330); + match(EXISTS); + } + break; + } + setState(7333); + name(); + setState(7334); + opt_drop_behavior(); + } + break; + case 6: + { + setState(7336); + match(VALIDATE); + setState(7337); + match(CONSTRAINT); + setState(7338); + name(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_asContext extends ParserRuleContext { + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public Opt_asContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_as; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_as(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_as(this); + } + } + + public final Opt_asContext opt_as() throws RecognitionException { + Opt_asContext _localctx = new Opt_asContext(_ctx, getState()); + enterRule(_localctx, 834, RULE_opt_as); + try { + setState(7343); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AS: + enterOuterAlt(_localctx, 1); + { + setState(7341); + match(AS); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltertsdictionarystmtContext extends ParserRuleContext { + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode TEXT_P() { return getToken(PostgreSqlParser.TEXT_P, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public DefinitionContext definition() { + return getRuleContext(DefinitionContext.class,0); + } + public AltertsdictionarystmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altertsdictionarystmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltertsdictionarystmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltertsdictionarystmt(this); + } + } + + public final AltertsdictionarystmtContext altertsdictionarystmt() throws RecognitionException { + AltertsdictionarystmtContext _localctx = new AltertsdictionarystmtContext(_ctx, getState()); + enterRule(_localctx, 836, RULE_altertsdictionarystmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7345); + match(ALTER); + setState(7346); + match(TEXT_P); + setState(7347); + match(SEARCH); + setState(7348); + match(DICTIONARY); + setState(7349); + any_name(); + setState(7350); + definition(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AltertsconfigurationstmtContext extends ParserRuleContext { + public List ALTER() { return getTokens(PostgreSqlParser.ALTER); } + public TerminalNode ALTER(int i) { + return getToken(PostgreSqlParser.ALTER, i); + } + public TerminalNode TEXT_P() { return getToken(PostgreSqlParser.TEXT_P, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } + public List any_name() { + return getRuleContexts(Any_nameContext.class); + } + public Any_nameContext any_name(int i) { + return getRuleContext(Any_nameContext.class,i); + } + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public TerminalNode MAPPING() { return getToken(PostgreSqlParser.MAPPING, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Name_listContext name_list() { + return getRuleContext(Name_listContext.class,0); + } + public Any_withContext any_with() { + return getRuleContext(Any_withContext.class,0); + } + public Any_name_listContext any_name_list() { + return getRuleContext(Any_name_listContext.class,0); + } + public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public AltertsconfigurationstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altertsconfigurationstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAltertsconfigurationstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAltertsconfigurationstmt(this); + } + } + + public final AltertsconfigurationstmtContext altertsconfigurationstmt() throws RecognitionException { + AltertsconfigurationstmtContext _localctx = new AltertsconfigurationstmtContext(_ctx, getState()); + enterRule(_localctx, 838, RULE_altertsconfigurationstmt); + try { + setState(7424); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,357,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7352); + match(ALTER); + setState(7353); + match(TEXT_P); + setState(7354); + match(SEARCH); + setState(7355); + match(CONFIGURATION); + setState(7356); + any_name(); + setState(7357); + match(ADD_P); + setState(7358); + match(MAPPING); + setState(7359); + match(FOR); + setState(7360); + name_list(); + setState(7361); + any_with(); + setState(7362); + any_name_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7364); + match(ALTER); + setState(7365); + match(TEXT_P); + setState(7366); + match(SEARCH); + setState(7367); + match(CONFIGURATION); + setState(7368); + any_name(); + setState(7369); + match(ALTER); + setState(7370); + match(MAPPING); + setState(7371); + match(FOR); + setState(7372); + name_list(); + setState(7373); + any_with(); + setState(7374); + any_name_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7376); + match(ALTER); + setState(7377); + match(TEXT_P); + setState(7378); + match(SEARCH); + setState(7379); + match(CONFIGURATION); + setState(7380); + any_name(); + setState(7381); + match(ALTER); + setState(7382); + match(MAPPING); + setState(7383); + match(REPLACE); + setState(7384); + any_name(); + setState(7385); + any_with(); + setState(7386); + any_name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7388); + match(ALTER); + setState(7389); + match(TEXT_P); + setState(7390); + match(SEARCH); + setState(7391); + match(CONFIGURATION); + setState(7392); + any_name(); + setState(7393); + match(ALTER); + setState(7394); + match(MAPPING); + setState(7395); + match(FOR); + setState(7396); + name_list(); + setState(7397); + match(REPLACE); + setState(7398); + any_name(); + setState(7399); + any_with(); + setState(7400); + any_name(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(7402); + match(ALTER); + setState(7403); + match(TEXT_P); + setState(7404); + match(SEARCH); + setState(7405); + match(CONFIGURATION); + setState(7406); + any_name(); + setState(7407); + match(DROP); + setState(7408); + match(MAPPING); + setState(7409); + match(FOR); + setState(7410); + name_list(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(7412); + match(ALTER); + setState(7413); + match(TEXT_P); + setState(7414); + match(SEARCH); + setState(7415); + match(CONFIGURATION); + setState(7416); + any_name(); + setState(7417); + match(DROP); + setState(7418); + match(MAPPING); + setState(7419); + match(IF_P); + setState(7420); + match(EXISTS); + setState(7421); + match(FOR); + setState(7422); + name_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Any_withContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public Any_withContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_any_with; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAny_with(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAny_with(this); + } + } + + public final Any_withContext any_with() throws RecognitionException { + Any_withContext _localctx = new Any_withContext(_ctx, getState()); + enterRule(_localctx, 840, RULE_any_with); + try { + enterOuterAlt(_localctx, 1); + { + setState(7426); + match(WITH); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CreateconversionstmtContext extends ParserRuleContext { + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public Opt_defaultContext opt_default() { + return getRuleContext(Opt_defaultContext.class,0); + } + public TerminalNode CONVERSION_P() { return getToken(PostgreSqlParser.CONVERSION_P, 0); } + public List any_name() { + return getRuleContexts(Any_nameContext.class); + } + public Any_nameContext any_name(int i) { + return getRuleContext(Any_nameContext.class,i); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public List sconst() { + return getRuleContexts(SconstContext.class); + } + public SconstContext sconst(int i) { + return getRuleContext(SconstContext.class,i); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public CreateconversionstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createconversionstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCreateconversionstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCreateconversionstmt(this); + } + } + + public final CreateconversionstmtContext createconversionstmt() throws RecognitionException { + CreateconversionstmtContext _localctx = new CreateconversionstmtContext(_ctx, getState()); + enterRule(_localctx, 842, RULE_createconversionstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7428); + match(CREATE); + setState(7429); + opt_default(); + setState(7430); + match(CONVERSION_P); + setState(7431); + any_name(); + setState(7432); + match(FOR); + setState(7433); + sconst(); + setState(7434); + match(TO); + setState(7435); + sconst(); + setState(7436); + match(FROM); + setState(7437); + any_name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClusterstmtContext extends ParserRuleContext { + public TerminalNode CLUSTER() { return getToken(PostgreSqlParser.CLUSTER, 0); } + public Opt_verboseContext opt_verbose() { + return getRuleContext(Opt_verboseContext.class,0); + } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Cluster_index_specificationContext cluster_index_specification() { + return getRuleContext(Cluster_index_specificationContext.class,0); + } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public ClusterstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_clusterstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterClusterstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitClusterstmt(this); + } + } + + public final ClusterstmtContext clusterstmt() throws RecognitionException { + ClusterstmtContext _localctx = new ClusterstmtContext(_ctx, getState()); + enterRule(_localctx, 844, RULE_clusterstmt); + try { + setState(7452); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,358,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7439); + match(CLUSTER); + setState(7440); + opt_verbose(); + setState(7441); + qualified_name(); + setState(7442); + cluster_index_specification(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7444); + match(CLUSTER); + setState(7445); + opt_verbose(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7446); + match(CLUSTER); + setState(7447); + opt_verbose(); + setState(7448); + name(); + setState(7449); + match(ON); + setState(7450); + qualified_name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cluster_index_specificationContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Cluster_index_specificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cluster_index_specification; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCluster_index_specification(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCluster_index_specification(this); + } + } + + public final Cluster_index_specificationContext cluster_index_specification() throws RecognitionException { + Cluster_index_specificationContext _localctx = new Cluster_index_specificationContext(_ctx, getState()); + enterRule(_localctx, 846, RULE_cluster_index_specification); + try { + setState(7457); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(7454); + match(USING); + setState(7455); + name(); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VacuumstmtContext extends ParserRuleContext { + public TerminalNode VACUUM() { return getToken(PostgreSqlParser.VACUUM, 0); } + public Opt_fullContext opt_full() { + return getRuleContext(Opt_fullContext.class,0); + } + public Opt_freezeContext opt_freeze() { + return getRuleContext(Opt_freezeContext.class,0); + } + public Opt_verboseContext opt_verbose() { + return getRuleContext(Opt_verboseContext.class,0); + } + public Opt_analyzeContext opt_analyze() { + return getRuleContext(Opt_analyzeContext.class,0); + } + public Opt_vacuum_relation_listContext opt_vacuum_relation_list() { + return getRuleContext(Opt_vacuum_relation_listContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Vac_analyze_option_listContext vac_analyze_option_list() { + return getRuleContext(Vac_analyze_option_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public VacuumstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vacuumstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVacuumstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVacuumstmt(this); + } + } + + public final VacuumstmtContext vacuumstmt() throws RecognitionException { + VacuumstmtContext _localctx = new VacuumstmtContext(_ctx, getState()); + enterRule(_localctx, 848, RULE_vacuumstmt); + try { + setState(7472); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,360,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7459); + match(VACUUM); + setState(7460); + opt_full(); + setState(7461); + opt_freeze(); + setState(7462); + opt_verbose(); + setState(7463); + opt_analyze(); + setState(7464); + opt_vacuum_relation_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7466); + match(VACUUM); + setState(7467); + match(OPEN_PAREN); + setState(7468); + vac_analyze_option_list(); + setState(7469); + match(CLOSE_PAREN); + setState(7470); + opt_vacuum_relation_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnalyzestmtContext extends ParserRuleContext { + public Analyze_keywordContext analyze_keyword() { + return getRuleContext(Analyze_keywordContext.class,0); + } + public Opt_verboseContext opt_verbose() { + return getRuleContext(Opt_verboseContext.class,0); + } + public Opt_vacuum_relation_listContext opt_vacuum_relation_list() { + return getRuleContext(Opt_vacuum_relation_listContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Vac_analyze_option_listContext vac_analyze_option_list() { + return getRuleContext(Vac_analyze_option_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public AnalyzestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_analyzestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAnalyzestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAnalyzestmt(this); + } + } + + public final AnalyzestmtContext analyzestmt() throws RecognitionException { + AnalyzestmtContext _localctx = new AnalyzestmtContext(_ctx, getState()); + enterRule(_localctx, 850, RULE_analyzestmt); + try { + setState(7484); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,361,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7474); + analyze_keyword(); + setState(7475); + opt_verbose(); + setState(7476); + opt_vacuum_relation_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7478); + analyze_keyword(); + setState(7479); + match(OPEN_PAREN); + setState(7480); + vac_analyze_option_list(); + setState(7481); + match(CLOSE_PAREN); + setState(7482); + opt_vacuum_relation_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Vac_analyze_option_listContext extends ParserRuleContext { + public List vac_analyze_option_elem() { + return getRuleContexts(Vac_analyze_option_elemContext.class); + } + public Vac_analyze_option_elemContext vac_analyze_option_elem(int i) { + return getRuleContext(Vac_analyze_option_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Vac_analyze_option_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vac_analyze_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVac_analyze_option_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVac_analyze_option_list(this); + } + } + + public final Vac_analyze_option_listContext vac_analyze_option_list() throws RecognitionException { + Vac_analyze_option_listContext _localctx = new Vac_analyze_option_listContext(_ctx, getState()); + enterRule(_localctx, 852, RULE_vac_analyze_option_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7486); + vac_analyze_option_elem(); + setState(7491); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7487); + match(COMMA); + setState(7488); + vac_analyze_option_elem(); + } + } + setState(7493); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Analyze_keywordContext extends ParserRuleContext { + public TerminalNode ANALYZE() { return getToken(PostgreSqlParser.ANALYZE, 0); } + public TerminalNode ANALYSE() { return getToken(PostgreSqlParser.ANALYSE, 0); } + public Analyze_keywordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_analyze_keyword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAnalyze_keyword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAnalyze_keyword(this); + } + } + + public final Analyze_keywordContext analyze_keyword() throws RecognitionException { + Analyze_keywordContext _localctx = new Analyze_keywordContext(_ctx, getState()); + enterRule(_localctx, 854, RULE_analyze_keyword); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7494); + _la = _input.LA(1); + if ( !(_la==ANALYSE || _la==ANALYZE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Vac_analyze_option_elemContext extends ParserRuleContext { + public Vac_analyze_option_nameContext vac_analyze_option_name() { + return getRuleContext(Vac_analyze_option_nameContext.class,0); + } + public Vac_analyze_option_argContext vac_analyze_option_arg() { + return getRuleContext(Vac_analyze_option_argContext.class,0); + } + public Vac_analyze_option_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vac_analyze_option_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVac_analyze_option_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVac_analyze_option_elem(this); + } + } + + public final Vac_analyze_option_elemContext vac_analyze_option_elem() throws RecognitionException { + Vac_analyze_option_elemContext _localctx = new Vac_analyze_option_elemContext(_ctx, getState()); + enterRule(_localctx, 856, RULE_vac_analyze_option_elem); + try { + enterOuterAlt(_localctx, 1); + { + setState(7496); + vac_analyze_option_name(); + setState(7497); + vac_analyze_option_arg(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Vac_analyze_option_nameContext extends ParserRuleContext { + public NonreservedwordContext nonreservedword() { + return getRuleContext(NonreservedwordContext.class,0); + } + public Analyze_keywordContext analyze_keyword() { + return getRuleContext(Analyze_keywordContext.class,0); + } + public Vac_analyze_option_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vac_analyze_option_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVac_analyze_option_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVac_analyze_option_name(this); + } + } + + public final Vac_analyze_option_nameContext vac_analyze_option_name() throws RecognitionException { + Vac_analyze_option_nameContext _localctx = new Vac_analyze_option_nameContext(_ctx, getState()); + enterRule(_localctx, 858, RULE_vac_analyze_option_name); + try { + setState(7501); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(7499); + nonreservedword(); + } + break; + case ANALYSE: + case ANALYZE: + enterOuterAlt(_localctx, 2); + { + setState(7500); + analyze_keyword(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Vac_analyze_option_argContext extends ParserRuleContext { + public Opt_boolean_or_stringContext opt_boolean_or_string() { + return getRuleContext(Opt_boolean_or_stringContext.class,0); + } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public Vac_analyze_option_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vac_analyze_option_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVac_analyze_option_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVac_analyze_option_arg(this); + } + } + + public final Vac_analyze_option_argContext vac_analyze_option_arg() throws RecognitionException { + Vac_analyze_option_argContext _localctx = new Vac_analyze_option_argContext(_ctx, getState()); + enterRule(_localctx, 860, RULE_vac_analyze_option_arg); + try { + setState(7506); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case ON: + case TABLE: + case TRUE_P: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(7503); + opt_boolean_or_string(); + } + break; + case PLUS: + case MINUS: + case Integral: + case Numeric: + enterOuterAlt(_localctx, 2); + { + setState(7504); + numericonly(); + } + break; + case CLOSE_PAREN: + case COMMA: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_analyzeContext extends ParserRuleContext { + public Analyze_keywordContext analyze_keyword() { + return getRuleContext(Analyze_keywordContext.class,0); + } + public Opt_analyzeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_analyze; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_analyze(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_analyze(this); + } + } + + public final Opt_analyzeContext opt_analyze() throws RecognitionException { + Opt_analyzeContext _localctx = new Opt_analyzeContext(_ctx, getState()); + enterRule(_localctx, 862, RULE_opt_analyze); + try { + setState(7510); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,365,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7508); + analyze_keyword(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_verboseContext extends ParserRuleContext { + public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } + public Opt_verboseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_verbose; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_verbose(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_verbose(this); + } + } + + public final Opt_verboseContext opt_verbose() throws RecognitionException { + Opt_verboseContext _localctx = new Opt_verboseContext(_ctx, getState()); + enterRule(_localctx, 864, RULE_opt_verbose); + try { + setState(7514); + _errHandler.sync(this); + switch (_input.LA(1)) { + case VERBOSE: + enterOuterAlt(_localctx, 1); + { + setState(7512); + match(VERBOSE); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CREATE: + case DEFAULT: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MERGE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case END_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_fullContext extends ParserRuleContext { + public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } + public Opt_fullContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_full; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_full(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_full(this); + } + } + + public final Opt_fullContext opt_full() throws RecognitionException { + Opt_fullContext _localctx = new Opt_fullContext(_ctx, getState()); + enterRule(_localctx, 866, RULE_opt_full); + try { + setState(7518); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FULL: + enterOuterAlt(_localctx, 1); + { + setState(7516); + match(FULL); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CREATE: + case DEFAULT: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case FREEZE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MERGE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case END_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_freezeContext extends ParserRuleContext { + public TerminalNode FREEZE() { return getToken(PostgreSqlParser.FREEZE, 0); } + public Opt_freezeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_freeze; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_freeze(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_freeze(this); + } + } + + public final Opt_freezeContext opt_freeze() throws RecognitionException { + Opt_freezeContext _localctx = new Opt_freezeContext(_ctx, getState()); + enterRule(_localctx, 868, RULE_opt_freeze); + try { + setState(7522); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FREEZE: + enterOuterAlt(_localctx, 1); + { + setState(7520); + match(FREEZE); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CREATE: + case DEFAULT: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MERGE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case END_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_name_listContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Name_listContext name_list() { + return getRuleContext(Name_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_name_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_name_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_name_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_name_list(this); + } + } + + public final Opt_name_listContext opt_name_list() throws RecognitionException { + Opt_name_listContext _localctx = new Opt_name_listContext(_ctx, getState()); + enterRule(_localctx, 870, RULE_opt_name_list); + try { + setState(7529); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,369,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7524); + match(OPEN_PAREN); + setState(7525); + name_list(); + setState(7526); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Vacuum_relationContext extends ParserRuleContext { + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public Opt_name_listContext opt_name_list() { + return getRuleContext(Opt_name_listContext.class,0); + } + public Vacuum_relationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vacuum_relation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVacuum_relation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVacuum_relation(this); + } + } + + public final Vacuum_relationContext vacuum_relation() throws RecognitionException { + Vacuum_relationContext _localctx = new Vacuum_relationContext(_ctx, getState()); + enterRule(_localctx, 872, RULE_vacuum_relation); + try { + enterOuterAlt(_localctx, 1); + { + setState(7531); + qualified_name(); + setState(7532); + opt_name_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Vacuum_relation_listContext extends ParserRuleContext { + public List vacuum_relation() { + return getRuleContexts(Vacuum_relationContext.class); + } + public Vacuum_relationContext vacuum_relation(int i) { + return getRuleContext(Vacuum_relationContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Vacuum_relation_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vacuum_relation_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVacuum_relation_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVacuum_relation_list(this); + } + } + + public final Vacuum_relation_listContext vacuum_relation_list() throws RecognitionException { + Vacuum_relation_listContext _localctx = new Vacuum_relation_listContext(_ctx, getState()); + enterRule(_localctx, 874, RULE_vacuum_relation_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7534); + vacuum_relation(); + setState(7539); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7535); + match(COMMA); + setState(7536); + vacuum_relation(); + } + } + setState(7541); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_vacuum_relation_listContext extends ParserRuleContext { + public Vacuum_relation_listContext vacuum_relation_list() { + return getRuleContext(Vacuum_relation_listContext.class,0); + } + public Opt_vacuum_relation_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_vacuum_relation_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_vacuum_relation_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_vacuum_relation_list(this); + } + } + + public final Opt_vacuum_relation_listContext opt_vacuum_relation_list() throws RecognitionException { + Opt_vacuum_relation_listContext _localctx = new Opt_vacuum_relation_listContext(_ctx, getState()); + enterRule(_localctx, 876, RULE_opt_vacuum_relation_list); + try { + setState(7544); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,371,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7542); + vacuum_relation_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExplainstmtContext extends ParserRuleContext { + public TerminalNode EXPLAIN() { return getToken(PostgreSqlParser.EXPLAIN, 0); } + public ExplainablestmtContext explainablestmt() { + return getRuleContext(ExplainablestmtContext.class,0); + } + public Analyze_keywordContext analyze_keyword() { + return getRuleContext(Analyze_keywordContext.class,0); + } + public Opt_verboseContext opt_verbose() { + return getRuleContext(Opt_verboseContext.class,0); + } + public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Explain_option_listContext explain_option_list() { + return getRuleContext(Explain_option_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ExplainstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explainstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplainstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplainstmt(this); + } + } + + public final ExplainstmtContext explainstmt() throws RecognitionException { + ExplainstmtContext _localctx = new ExplainstmtContext(_ctx, getState()); + enterRule(_localctx, 878, RULE_explainstmt); + try { + setState(7562); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,372,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7546); + match(EXPLAIN); + setState(7547); + explainablestmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7548); + match(EXPLAIN); + setState(7549); + analyze_keyword(); + setState(7550); + opt_verbose(); + setState(7551); + explainablestmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7553); + match(EXPLAIN); + setState(7554); + match(VERBOSE); + setState(7555); + explainablestmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7556); + match(EXPLAIN); + setState(7557); + match(OPEN_PAREN); + setState(7558); + explain_option_list(); + setState(7559); + match(CLOSE_PAREN); + setState(7560); + explainablestmt(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExplainablestmtContext extends ParserRuleContext { + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public InsertstmtContext insertstmt() { + return getRuleContext(InsertstmtContext.class,0); + } + public UpdatestmtContext updatestmt() { + return getRuleContext(UpdatestmtContext.class,0); + } + public DeletestmtContext deletestmt() { + return getRuleContext(DeletestmtContext.class,0); + } + public DeclarecursorstmtContext declarecursorstmt() { + return getRuleContext(DeclarecursorstmtContext.class,0); + } + public CreateasstmtContext createasstmt() { + return getRuleContext(CreateasstmtContext.class,0); + } + public CreatematviewstmtContext creatematviewstmt() { + return getRuleContext(CreatematviewstmtContext.class,0); + } + public RefreshmatviewstmtContext refreshmatviewstmt() { + return getRuleContext(RefreshmatviewstmtContext.class,0); + } + public ExecutestmtContext executestmt() { + return getRuleContext(ExecutestmtContext.class,0); + } + public ExplainablestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explainablestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplainablestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplainablestmt(this); + } + } + + public final ExplainablestmtContext explainablestmt() throws RecognitionException { + ExplainablestmtContext _localctx = new ExplainablestmtContext(_ctx, getState()); + enterRule(_localctx, 880, RULE_explainablestmt); + try { + setState(7573); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,373,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7564); + selectstmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7565); + insertstmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7566); + updatestmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7567); + deletestmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(7568); + declarecursorstmt(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(7569); + createasstmt(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(7570); + creatematviewstmt(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(7571); + refreshmatviewstmt(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(7572); + executestmt(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Explain_option_listContext extends ParserRuleContext { + public List explain_option_elem() { + return getRuleContexts(Explain_option_elemContext.class); + } + public Explain_option_elemContext explain_option_elem(int i) { + return getRuleContext(Explain_option_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Explain_option_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explain_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplain_option_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplain_option_list(this); + } + } + + public final Explain_option_listContext explain_option_list() throws RecognitionException { + Explain_option_listContext _localctx = new Explain_option_listContext(_ctx, getState()); + enterRule(_localctx, 882, RULE_explain_option_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7575); + explain_option_elem(); + setState(7580); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7576); + match(COMMA); + setState(7577); + explain_option_elem(); + } + } + setState(7582); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Explain_option_elemContext extends ParserRuleContext { + public Explain_option_nameContext explain_option_name() { + return getRuleContext(Explain_option_nameContext.class,0); + } + public Explain_option_argContext explain_option_arg() { + return getRuleContext(Explain_option_argContext.class,0); + } + public Explain_option_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explain_option_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplain_option_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplain_option_elem(this); + } + } + + public final Explain_option_elemContext explain_option_elem() throws RecognitionException { + Explain_option_elemContext _localctx = new Explain_option_elemContext(_ctx, getState()); + enterRule(_localctx, 884, RULE_explain_option_elem); + try { + enterOuterAlt(_localctx, 1); + { + setState(7583); + explain_option_name(); + setState(7584); + explain_option_arg(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Explain_option_nameContext extends ParserRuleContext { + public NonreservedwordContext nonreservedword() { + return getRuleContext(NonreservedwordContext.class,0); + } + public Analyze_keywordContext analyze_keyword() { + return getRuleContext(Analyze_keywordContext.class,0); + } + public Explain_option_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explain_option_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplain_option_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplain_option_name(this); + } + } + + public final Explain_option_nameContext explain_option_name() throws RecognitionException { + Explain_option_nameContext _localctx = new Explain_option_nameContext(_ctx, getState()); + enterRule(_localctx, 886, RULE_explain_option_name); + try { + setState(7588); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(7586); + nonreservedword(); + } + break; + case ANALYSE: + case ANALYZE: + enterOuterAlt(_localctx, 2); + { + setState(7587); + analyze_keyword(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Explain_option_argContext extends ParserRuleContext { + public Opt_boolean_or_stringContext opt_boolean_or_string() { + return getRuleContext(Opt_boolean_or_stringContext.class,0); + } + public NumericonlyContext numericonly() { + return getRuleContext(NumericonlyContext.class,0); + } + public Explain_option_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explain_option_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplain_option_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplain_option_arg(this); + } + } + + public final Explain_option_argContext explain_option_arg() throws RecognitionException { + Explain_option_argContext _localctx = new Explain_option_argContext(_ctx, getState()); + enterRule(_localctx, 888, RULE_explain_option_arg); + try { + setState(7593); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case ON: + case TABLE: + case TRUE_P: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(7590); + opt_boolean_or_string(); + } + break; + case PLUS: + case MINUS: + case Integral: + case Numeric: + enterOuterAlt(_localctx, 2); + { + setState(7591); + numericonly(); + } + break; + case CLOSE_PAREN: + case COMMA: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PreparestmtContext extends ParserRuleContext { + public TerminalNode PREPARE() { return getToken(PostgreSqlParser.PREPARE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Prep_type_clauseContext prep_type_clause() { + return getRuleContext(Prep_type_clauseContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public PreparablestmtContext preparablestmt() { + return getRuleContext(PreparablestmtContext.class,0); + } + public PreparestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_preparestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPreparestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPreparestmt(this); + } + } + + public final PreparestmtContext preparestmt() throws RecognitionException { + PreparestmtContext _localctx = new PreparestmtContext(_ctx, getState()); + enterRule(_localctx, 890, RULE_preparestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7595); + match(PREPARE); + setState(7596); + name(); + setState(7597); + prep_type_clause(); + setState(7598); + match(AS); + setState(7599); + preparablestmt(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Prep_type_clauseContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Type_listContext type_list() { + return getRuleContext(Type_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Prep_type_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_prep_type_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPrep_type_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPrep_type_clause(this); + } + } + + public final Prep_type_clauseContext prep_type_clause() throws RecognitionException { + Prep_type_clauseContext _localctx = new Prep_type_clauseContext(_ctx, getState()); + enterRule(_localctx, 892, RULE_prep_type_clause); + try { + setState(7606); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + enterOuterAlt(_localctx, 1); + { + setState(7601); + match(OPEN_PAREN); + setState(7602); + type_list(); + setState(7603); + match(CLOSE_PAREN); + } + break; + case AS: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PreparablestmtContext extends ParserRuleContext { + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public InsertstmtContext insertstmt() { + return getRuleContext(InsertstmtContext.class,0); + } + public UpdatestmtContext updatestmt() { + return getRuleContext(UpdatestmtContext.class,0); + } + public DeletestmtContext deletestmt() { + return getRuleContext(DeletestmtContext.class,0); + } + public PreparablestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_preparablestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPreparablestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPreparablestmt(this); + } + } + + public final PreparablestmtContext preparablestmt() throws RecognitionException { + PreparablestmtContext _localctx = new PreparablestmtContext(_ctx, getState()); + enterRule(_localctx, 894, RULE_preparablestmt); + try { + setState(7612); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,378,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7608); + selectstmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7609); + insertstmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7610); + updatestmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7611); + deletestmt(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExecutestmtContext extends ParserRuleContext { + public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Execute_param_clauseContext execute_param_clause() { + return getRuleContext(Execute_param_clauseContext.class,0); + } + public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } + public OpttempContext opttemp() { + return getRuleContext(OpttempContext.class,0); + } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Create_as_targetContext create_as_target() { + return getRuleContext(Create_as_targetContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public Opt_with_dataContext opt_with_data() { + return getRuleContext(Opt_with_dataContext.class,0); + } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public ExecutestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_executestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExecutestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExecutestmt(this); + } + } + + public final ExecutestmtContext executestmt() throws RecognitionException { + ExecutestmtContext _localctx = new ExecutestmtContext(_ctx, getState()); + enterRule(_localctx, 896, RULE_executestmt); + try { + setState(7641); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,379,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7614); + match(EXECUTE); + setState(7615); + name(); + setState(7616); + execute_param_clause(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7618); + match(CREATE); + setState(7619); + opttemp(); + setState(7620); + match(TABLE); + setState(7621); + create_as_target(); + setState(7622); + match(AS); + setState(7623); + match(EXECUTE); + setState(7624); + name(); + setState(7625); + execute_param_clause(); + setState(7626); + opt_with_data(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7628); + match(CREATE); + setState(7629); + opttemp(); + setState(7630); + match(TABLE); + setState(7631); + match(IF_P); + setState(7632); + match(NOT); + setState(7633); + match(EXISTS); + setState(7634); + create_as_target(); + setState(7635); + match(AS); + setState(7636); + match(EXECUTE); + setState(7637); + name(); + setState(7638); + execute_param_clause(); + setState(7639); + opt_with_data(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Execute_param_clauseContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Execute_param_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_execute_param_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExecute_param_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExecute_param_clause(this); + } + } + + public final Execute_param_clauseContext execute_param_clause() throws RecognitionException { + Execute_param_clauseContext _localctx = new Execute_param_clauseContext(_ctx, getState()); + enterRule(_localctx, 898, RULE_execute_param_clause); + try { + setState(7648); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,380,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7643); + match(OPEN_PAREN); + setState(7644); + expr_list(); + setState(7645); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeallocatestmtContext extends ParserRuleContext { + public TerminalNode DEALLOCATE() { return getToken(PostgreSqlParser.DEALLOCATE, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public TerminalNode PREPARE() { return getToken(PostgreSqlParser.PREPARE, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public DeallocatestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_deallocatestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDeallocatestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDeallocatestmt(this); + } + } + + public final DeallocatestmtContext deallocatestmt() throws RecognitionException { + DeallocatestmtContext _localctx = new DeallocatestmtContext(_ctx, getState()); + enterRule(_localctx, 900, RULE_deallocatestmt); + try { + setState(7660); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,381,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7650); + match(DEALLOCATE); + setState(7651); + name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7652); + match(DEALLOCATE); + setState(7653); + match(PREPARE); + setState(7654); + name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7655); + match(DEALLOCATE); + setState(7656); + match(ALL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7657); + match(DEALLOCATE); + setState(7658); + match(PREPARE); + setState(7659); + match(ALL); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InsertstmtContext extends ParserRuleContext { + public Opt_with_clauseContext opt_with_clause() { + return getRuleContext(Opt_with_clauseContext.class,0); + } + public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } + public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } + public Insert_targetContext insert_target() { + return getRuleContext(Insert_targetContext.class,0); + } + public Insert_restContext insert_rest() { + return getRuleContext(Insert_restContext.class,0); + } + public Opt_on_conflictContext opt_on_conflict() { + return getRuleContext(Opt_on_conflictContext.class,0); + } + public Returning_clauseContext returning_clause() { + return getRuleContext(Returning_clauseContext.class,0); + } + public InsertstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_insertstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInsertstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInsertstmt(this); + } + } + + public final InsertstmtContext insertstmt() throws RecognitionException { + InsertstmtContext _localctx = new InsertstmtContext(_ctx, getState()); + enterRule(_localctx, 902, RULE_insertstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7662); + opt_with_clause(); + setState(7663); + match(INSERT); + setState(7664); + match(INTO); + setState(7665); + insert_target(); + setState(7666); + insert_rest(); + setState(7667); + opt_on_conflict(); + setState(7668); + returning_clause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Insert_targetContext extends ParserRuleContext { + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Insert_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_insert_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInsert_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInsert_target(this); + } + } + + public final Insert_targetContext insert_target() throws RecognitionException { + Insert_targetContext _localctx = new Insert_targetContext(_ctx, getState()); + enterRule(_localctx, 904, RULE_insert_target); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7670); + qualified_name(); + setState(7673); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(7671); + match(AS); + setState(7672); + colid(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Insert_restContext extends ParserRuleContext { + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public TerminalNode OVERRIDING() { return getToken(PostgreSqlParser.OVERRIDING, 0); } + public Override_kindContext override_kind() { + return getRuleContext(Override_kindContext.class,0); + } + public TerminalNode VALUE_P() { return getToken(PostgreSqlParser.VALUE_P, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Insert_column_listContext insert_column_list() { + return getRuleContext(Insert_column_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public TerminalNode VALUES() { return getToken(PostgreSqlParser.VALUES, 0); } + public Insert_restContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_insert_rest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInsert_rest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInsert_rest(this); + } + } + + public final Insert_restContext insert_rest() throws RecognitionException { + Insert_restContext _localctx = new Insert_restContext(_ctx, getState()); + enterRule(_localctx, 906, RULE_insert_rest); + int _la; + try { + setState(7694); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,384,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7675); + selectstmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7676); + match(OVERRIDING); + setState(7677); + override_kind(); + setState(7678); + match(VALUE_P); + setState(7679); + selectstmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(7681); + match(OPEN_PAREN); + setState(7682); + insert_column_list(); + setState(7683); + match(CLOSE_PAREN); + setState(7688); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OVERRIDING) { + { + setState(7684); + match(OVERRIDING); + setState(7685); + override_kind(); + setState(7686); + match(VALUE_P); + } + } + + setState(7690); + selectstmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(7692); + match(DEFAULT); + setState(7693); + match(VALUES); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Override_kindContext extends ParserRuleContext { + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode SYSTEM_P() { return getToken(PostgreSqlParser.SYSTEM_P, 0); } + public Override_kindContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_override_kind; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOverride_kind(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOverride_kind(this); + } + } + + public final Override_kindContext override_kind() throws RecognitionException { + Override_kindContext _localctx = new Override_kindContext(_ctx, getState()); + enterRule(_localctx, 908, RULE_override_kind); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7696); + _la = _input.LA(1); + if ( !(_la==USER || _la==SYSTEM_P) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Insert_column_listContext extends ParserRuleContext { + public List insert_column_item() { + return getRuleContexts(Insert_column_itemContext.class); + } + public Insert_column_itemContext insert_column_item(int i) { + return getRuleContext(Insert_column_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Insert_column_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_insert_column_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInsert_column_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInsert_column_list(this); + } + } + + public final Insert_column_listContext insert_column_list() throws RecognitionException { + Insert_column_listContext _localctx = new Insert_column_listContext(_ctx, getState()); + enterRule(_localctx, 910, RULE_insert_column_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7698); + insert_column_item(); + setState(7703); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7699); + match(COMMA); + setState(7700); + insert_column_item(); + } + } + setState(7705); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Insert_column_itemContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Opt_indirectionContext opt_indirection() { + return getRuleContext(Opt_indirectionContext.class,0); + } + public Insert_column_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_insert_column_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInsert_column_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInsert_column_item(this); + } + } + + public final Insert_column_itemContext insert_column_item() throws RecognitionException { + Insert_column_itemContext _localctx = new Insert_column_itemContext(_ctx, getState()); + enterRule(_localctx, 912, RULE_insert_column_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(7706); + colid(); + setState(7707); + opt_indirection(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_on_conflictContext extends ParserRuleContext { + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public TerminalNode CONFLICT() { return getToken(PostgreSqlParser.CONFLICT, 0); } + public Opt_conf_exprContext opt_conf_expr() { + return getRuleContext(Opt_conf_exprContext.class,0); + } + public TerminalNode DO() { return getToken(PostgreSqlParser.DO, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public Set_clause_listContext set_clause_list() { + return getRuleContext(Set_clause_listContext.class,0); + } + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class,0); + } + public TerminalNode NOTHING() { return getToken(PostgreSqlParser.NOTHING, 0); } + public Opt_on_conflictContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_on_conflict; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_on_conflict(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_on_conflict(this); + } + } + + public final Opt_on_conflictContext opt_on_conflict() throws RecognitionException { + Opt_on_conflictContext _localctx = new Opt_on_conflictContext(_ctx, getState()); + enterRule(_localctx, 914, RULE_opt_on_conflict); + try { + setState(7722); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ON: + enterOuterAlt(_localctx, 1); + { + setState(7709); + match(ON); + setState(7710); + match(CONFLICT); + setState(7711); + opt_conf_expr(); + setState(7712); + match(DO); + setState(7719); + _errHandler.sync(this); + switch (_input.LA(1)) { + case UPDATE: + { + setState(7713); + match(UPDATE); + setState(7714); + match(SET); + setState(7715); + set_clause_list(); + setState(7716); + where_clause(); + } + break; + case NOTHING: + { + setState(7718); + match(NOTHING); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case RETURNING: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_conf_exprContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Index_paramsContext index_params() { + return getRuleContext(Index_paramsContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class,0); + } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_conf_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_conf_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_conf_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_conf_expr(this); + } + } + + public final Opt_conf_exprContext opt_conf_expr() throws RecognitionException { + Opt_conf_exprContext _localctx = new Opt_conf_exprContext(_ctx, getState()); + enterRule(_localctx, 916, RULE_opt_conf_expr); + try { + setState(7733); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + enterOuterAlt(_localctx, 1); + { + setState(7724); + match(OPEN_PAREN); + setState(7725); + index_params(); + setState(7726); + match(CLOSE_PAREN); + setState(7727); + where_clause(); + } + break; + case ON: + enterOuterAlt(_localctx, 2); + { + setState(7729); + match(ON); + setState(7730); + match(CONSTRAINT); + setState(7731); + name(); + } + break; + case DO: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Returning_clauseContext extends ParserRuleContext { + public TerminalNode RETURNING() { return getToken(PostgreSqlParser.RETURNING, 0); } + public Target_listContext target_list() { + return getRuleContext(Target_listContext.class,0); + } + public Returning_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returning_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReturning_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReturning_clause(this); + } + } + + public final Returning_clauseContext returning_clause() throws RecognitionException { + Returning_clauseContext _localctx = new Returning_clauseContext(_ctx, getState()); + enterRule(_localctx, 918, RULE_returning_clause); + try { + setState(7738); + _errHandler.sync(this); + switch (_input.LA(1)) { + case RETURNING: + enterOuterAlt(_localctx, 1); + { + setState(7735); + match(RETURNING); + setState(7736); + target_list(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MergestmtContext extends ParserRuleContext { + public TerminalNode MERGE() { return getToken(PostgreSqlParser.MERGE, 0); } + public List qualified_name() { + return getRuleContexts(Qualified_nameContext.class); + } + public Qualified_nameContext qualified_name(int i) { + return getRuleContext(Qualified_nameContext.class,i); + } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public Merge_insert_clauseContext merge_insert_clause() { + return getRuleContext(Merge_insert_clauseContext.class,0); + } + public Merge_update_clauseContext merge_update_clause() { + return getRuleContext(Merge_update_clauseContext.class,0); + } + public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } + public List alias_clause() { + return getRuleContexts(Alias_clauseContext.class); + } + public Alias_clauseContext alias_clause(int i) { + return getRuleContext(Alias_clauseContext.class,i); + } + public Merge_delete_clauseContext merge_delete_clause() { + return getRuleContext(Merge_delete_clauseContext.class,0); + } + public MergestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mergestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterMergestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitMergestmt(this); + } + } + + public final MergestmtContext mergestmt() throws RecognitionException { + MergestmtContext _localctx = new MergestmtContext(_ctx, getState()); + enterRule(_localctx, 920, RULE_mergestmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7740); + match(MERGE); + setState(7742); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTO) { + { + setState(7741); + match(INTO); + } + } + + setState(7744); + qualified_name(); + setState(7746); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8610635750251167744L) != 0) || ((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & -113665638399L) != 0) || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & -1L) != 0) || ((((_la - 222)) & ~0x3f) == 0 && ((1L << (_la - 222)) & -9663676417L) != 0) || ((((_la - 286)) & ~0x3f) == 0 && ((1L << (_la - 286)) & -1L) != 0) || ((((_la - 350)) & ~0x3f) == 0 && ((1L << (_la - 350)) & -1L) != 0) || ((((_la - 414)) & ~0x3f) == 0 && ((1L << (_la - 414)) & -1152925902653358081L) != 0) || ((((_la - 478)) & ~0x3f) == 0 && ((1L << (_la - 478)) & -43981136199681L) != 0) || ((((_la - 542)) & ~0x3f) == 0 && ((1L << (_la - 542)) & -1L) != 0) || ((((_la - 606)) & ~0x3f) == 0 && ((1L << (_la - 606)) & 288230685389357055L) != 0)) { + { + setState(7745); + alias_clause(); + } + } + + setState(7748); + match(USING); + setState(7751); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + { + setState(7749); + select_with_parens(); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(7750); + qualified_name(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(7754); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8610635750251167744L) != 0) || ((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & -113665638399L) != 0) || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & -1L) != 0) || ((((_la - 222)) & ~0x3f) == 0 && ((1L << (_la - 222)) & -9663676417L) != 0) || ((((_la - 286)) & ~0x3f) == 0 && ((1L << (_la - 286)) & -1L) != 0) || ((((_la - 350)) & ~0x3f) == 0 && ((1L << (_la - 350)) & -1L) != 0) || ((((_la - 414)) & ~0x3f) == 0 && ((1L << (_la - 414)) & -1152925902653358081L) != 0) || ((((_la - 478)) & ~0x3f) == 0 && ((1L << (_la - 478)) & -43981136199681L) != 0) || ((((_la - 542)) & ~0x3f) == 0 && ((1L << (_la - 542)) & -1L) != 0) || ((((_la - 606)) & ~0x3f) == 0 && ((1L << (_la - 606)) & 288230685389357055L) != 0)) { + { + setState(7753); + alias_clause(); + } + } + + setState(7756); + match(ON); + setState(7757); + a_expr(); + setState(7766); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,396,_ctx) ) { + case 1: + { + setState(7758); + merge_insert_clause(); + setState(7760); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,394,_ctx) ) { + case 1: + { + setState(7759); + merge_update_clause(); + } + break; + } + } + break; + case 2: + { + setState(7762); + merge_update_clause(); + setState(7764); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,395,_ctx) ) { + case 1: + { + setState(7763); + merge_insert_clause(); + } + break; + } + } + break; + } + setState(7769); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHEN) { + { + setState(7768); + merge_delete_clause(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Merge_insert_clauseContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode MATCHED() { return getToken(PostgreSqlParser.MATCHED, 0); } + public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } + public Values_clauseContext values_clause() { + return getRuleContext(Values_clauseContext.class,0); + } + public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode THEN() { return getToken(PostgreSqlParser.THEN, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Insert_column_listContext insert_column_list() { + return getRuleContext(Insert_column_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Merge_insert_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_merge_insert_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterMerge_insert_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitMerge_insert_clause(this); + } + } + + public final Merge_insert_clauseContext merge_insert_clause() throws RecognitionException { + Merge_insert_clauseContext _localctx = new Merge_insert_clauseContext(_ctx, getState()); + enterRule(_localctx, 922, RULE_merge_insert_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7771); + match(WHEN); + setState(7772); + match(NOT); + setState(7773); + match(MATCHED); + setState(7776); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AND) { + { + setState(7774); + match(AND); + setState(7775); + a_expr(); + } + } + + setState(7779); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==THEN) { + { + setState(7778); + match(THEN); + } + } + + setState(7781); + match(INSERT); + setState(7786); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(7782); + match(OPEN_PAREN); + setState(7783); + insert_column_list(); + setState(7784); + match(CLOSE_PAREN); + } + } + + setState(7788); + values_clause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Merge_update_clauseContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public TerminalNode MATCHED() { return getToken(PostgreSqlParser.MATCHED, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public Set_clause_listContext set_clause_list() { + return getRuleContext(Set_clause_listContext.class,0); + } + public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode THEN() { return getToken(PostgreSqlParser.THEN, 0); } + public Merge_update_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_merge_update_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterMerge_update_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitMerge_update_clause(this); + } + } + + public final Merge_update_clauseContext merge_update_clause() throws RecognitionException { + Merge_update_clauseContext _localctx = new Merge_update_clauseContext(_ctx, getState()); + enterRule(_localctx, 924, RULE_merge_update_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7790); + match(WHEN); + setState(7791); + match(MATCHED); + setState(7794); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AND) { + { + setState(7792); + match(AND); + setState(7793); + a_expr(); + } + } + + setState(7797); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==THEN) { + { + setState(7796); + match(THEN); + } + } + + setState(7799); + match(UPDATE); + setState(7800); + match(SET); + setState(7801); + set_clause_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Merge_delete_clauseContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public TerminalNode MATCHED() { return getToken(PostgreSqlParser.MATCHED, 0); } + public TerminalNode DELETE_P() { return getToken(PostgreSqlParser.DELETE_P, 0); } + public TerminalNode THEN() { return getToken(PostgreSqlParser.THEN, 0); } + public Merge_delete_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_merge_delete_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterMerge_delete_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitMerge_delete_clause(this); + } + } + + public final Merge_delete_clauseContext merge_delete_clause() throws RecognitionException { + Merge_delete_clauseContext _localctx = new Merge_delete_clauseContext(_ctx, getState()); + enterRule(_localctx, 926, RULE_merge_delete_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7803); + match(WHEN); + setState(7804); + match(MATCHED); + setState(7806); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==THEN) { + { + setState(7805); + match(THEN); + } + } + + setState(7808); + match(DELETE_P); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeletestmtContext extends ParserRuleContext { + public Opt_with_clauseContext opt_with_clause() { + return getRuleContext(Opt_with_clauseContext.class,0); + } + public TerminalNode DELETE_P() { return getToken(PostgreSqlParser.DELETE_P, 0); } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public Relation_expr_opt_aliasContext relation_expr_opt_alias() { + return getRuleContext(Relation_expr_opt_aliasContext.class,0); + } + public Using_clauseContext using_clause() { + return getRuleContext(Using_clauseContext.class,0); + } + public Where_or_current_clauseContext where_or_current_clause() { + return getRuleContext(Where_or_current_clauseContext.class,0); + } + public Returning_clauseContext returning_clause() { + return getRuleContext(Returning_clauseContext.class,0); + } + public DeletestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_deletestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDeletestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDeletestmt(this); + } + } + + public final DeletestmtContext deletestmt() throws RecognitionException { + DeletestmtContext _localctx = new DeletestmtContext(_ctx, getState()); + enterRule(_localctx, 928, RULE_deletestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7810); + opt_with_clause(); + setState(7811); + match(DELETE_P); + setState(7812); + match(FROM); + setState(7813); + relation_expr_opt_alias(); + setState(7814); + using_clause(); + setState(7815); + where_or_current_clause(); + setState(7816); + returning_clause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Using_clauseContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public From_listContext from_list() { + return getRuleContext(From_listContext.class,0); + } + public Using_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_using_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUsing_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUsing_clause(this); + } + } + + public final Using_clauseContext using_clause() throws RecognitionException { + Using_clauseContext _localctx = new Using_clauseContext(_ctx, getState()); + enterRule(_localctx, 930, RULE_using_clause); + try { + setState(7821); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(7818); + match(USING); + setState(7819); + from_list(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case RETURNING: + case SELECT: + case TABLE: + case WHERE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LockstmtContext extends ParserRuleContext { + public TerminalNode LOCK_P() { return getToken(PostgreSqlParser.LOCK_P, 0); } + public Opt_tableContext opt_table() { + return getRuleContext(Opt_tableContext.class,0); + } + public Relation_expr_listContext relation_expr_list() { + return getRuleContext(Relation_expr_listContext.class,0); + } + public Opt_lockContext opt_lock() { + return getRuleContext(Opt_lockContext.class,0); + } + public Opt_nowaitContext opt_nowait() { + return getRuleContext(Opt_nowaitContext.class,0); + } + public LockstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lockstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLockstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLockstmt(this); + } + } + + public final LockstmtContext lockstmt() throws RecognitionException { + LockstmtContext _localctx = new LockstmtContext(_ctx, getState()); + enterRule(_localctx, 932, RULE_lockstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7823); + match(LOCK_P); + setState(7824); + opt_table(); + setState(7825); + relation_expr_list(); + setState(7826); + opt_lock(); + setState(7827); + opt_nowait(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_lockContext extends ParserRuleContext { + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public Lock_typeContext lock_type() { + return getRuleContext(Lock_typeContext.class,0); + } + public TerminalNode MODE() { return getToken(PostgreSqlParser.MODE, 0); } + public Opt_lockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_lock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_lock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_lock(this); + } + } + + public final Opt_lockContext opt_lock() throws RecognitionException { + Opt_lockContext _localctx = new Opt_lockContext(_ctx, getState()); + enterRule(_localctx, 934, RULE_opt_lock); + try { + setState(7834); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IN_P: + enterOuterAlt(_localctx, 1); + { + setState(7829); + match(IN_P); + setState(7830); + lock_type(); + setState(7831); + match(MODE); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case NOWAIT: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lock_typeContext extends ParserRuleContext { + public TerminalNode ACCESS() { return getToken(PostgreSqlParser.ACCESS, 0); } + public TerminalNode SHARE() { return getToken(PostgreSqlParser.SHARE, 0); } + public TerminalNode EXCLUSIVE() { return getToken(PostgreSqlParser.EXCLUSIVE, 0); } + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public Lock_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lock_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLock_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLock_type(this); + } + } + + public final Lock_typeContext lock_type() throws RecognitionException { + Lock_typeContext _localctx = new Lock_typeContext(_ctx, getState()); + enterRule(_localctx, 936, RULE_lock_type); + int _la; + try { + setState(7848); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ACCESS: + enterOuterAlt(_localctx, 1); + { + setState(7836); + match(ACCESS); + setState(7837); + _la = _input.LA(1); + if ( !(_la==EXCLUSIVE || _la==SHARE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case ROW: + enterOuterAlt(_localctx, 2); + { + setState(7838); + match(ROW); + setState(7839); + _la = _input.LA(1); + if ( !(_la==EXCLUSIVE || _la==SHARE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case SHARE: + enterOuterAlt(_localctx, 3); + { + setState(7840); + match(SHARE); + setState(7845); + _errHandler.sync(this); + switch (_input.LA(1)) { + case UPDATE: + { + setState(7841); + match(UPDATE); + setState(7842); + match(EXCLUSIVE); + } + break; + case ROW: + { + setState(7843); + match(ROW); + setState(7844); + match(EXCLUSIVE); + } + break; + case MODE: + break; + default: + break; + } + } + break; + case EXCLUSIVE: + enterOuterAlt(_localctx, 4); + { + setState(7847); + match(EXCLUSIVE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_nowaitContext extends ParserRuleContext { + public TerminalNode NOWAIT() { return getToken(PostgreSqlParser.NOWAIT, 0); } + public Opt_nowaitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_nowait; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_nowait(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_nowait(this); + } + } + + public final Opt_nowaitContext opt_nowait() throws RecognitionException { + Opt_nowaitContext _localctx = new Opt_nowaitContext(_ctx, getState()); + enterRule(_localctx, 938, RULE_opt_nowait); + try { + setState(7852); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOWAIT: + enterOuterAlt(_localctx, 1); + { + setState(7850); + match(NOWAIT); + } + break; + case EOF: + case OPEN_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_nowait_or_skipContext extends ParserRuleContext { + public TerminalNode NOWAIT() { return getToken(PostgreSqlParser.NOWAIT, 0); } + public TerminalNode SKIP_P() { return getToken(PostgreSqlParser.SKIP_P, 0); } + public TerminalNode LOCKED() { return getToken(PostgreSqlParser.LOCKED, 0); } + public Opt_nowait_or_skipContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_nowait_or_skip; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_nowait_or_skip(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_nowait_or_skip(this); + } + } + + public final Opt_nowait_or_skipContext opt_nowait_or_skip() throws RecognitionException { + Opt_nowait_or_skipContext _localctx = new Opt_nowait_or_skipContext(_ctx, getState()); + enterRule(_localctx, 940, RULE_opt_nowait_or_skip); + try { + setState(7858); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOWAIT: + enterOuterAlt(_localctx, 1); + { + setState(7854); + match(NOWAIT); + } + break; + case SKIP_P: + enterOuterAlt(_localctx, 2); + { + setState(7855); + match(SKIP_P); + setState(7856); + match(LOCKED); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case FOR: + case GRANT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case RETURNING: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UpdatestmtContext extends ParserRuleContext { + public Opt_with_clauseContext opt_with_clause() { + return getRuleContext(Opt_with_clauseContext.class,0); + } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public Relation_expr_opt_aliasContext relation_expr_opt_alias() { + return getRuleContext(Relation_expr_opt_aliasContext.class,0); + } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public Set_clause_listContext set_clause_list() { + return getRuleContext(Set_clause_listContext.class,0); + } + public From_clauseContext from_clause() { + return getRuleContext(From_clauseContext.class,0); + } + public Where_or_current_clauseContext where_or_current_clause() { + return getRuleContext(Where_or_current_clauseContext.class,0); + } + public Returning_clauseContext returning_clause() { + return getRuleContext(Returning_clauseContext.class,0); + } + public UpdatestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_updatestmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUpdatestmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUpdatestmt(this); + } + } + + public final UpdatestmtContext updatestmt() throws RecognitionException { + UpdatestmtContext _localctx = new UpdatestmtContext(_ctx, getState()); + enterRule(_localctx, 942, RULE_updatestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7860); + opt_with_clause(); + setState(7861); + match(UPDATE); + setState(7862); + relation_expr_opt_alias(); + setState(7863); + match(SET); + setState(7864); + set_clause_list(); + setState(7865); + from_clause(); + setState(7866); + where_or_current_clause(); + setState(7867); + returning_clause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Set_clause_listContext extends ParserRuleContext { + public List set_clause() { + return getRuleContexts(Set_clauseContext.class); + } + public Set_clauseContext set_clause(int i) { + return getRuleContext(Set_clauseContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Set_clause_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_clause_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_clause_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_clause_list(this); + } + } + + public final Set_clause_listContext set_clause_list() throws RecognitionException { + Set_clause_listContext _localctx = new Set_clause_listContext(_ctx, getState()); + enterRule(_localctx, 944, RULE_set_clause_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7869); + set_clause(); + setState(7874); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7870); + match(COMMA); + setState(7871); + set_clause(); + } + } + setState(7876); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Set_clauseContext extends ParserRuleContext { + public Set_targetContext set_target() { + return getRuleContext(Set_targetContext.class,0); + } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Set_target_listContext set_target_list() { + return getRuleContext(Set_target_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Set_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_clause(this); + } + } + + public final Set_clauseContext set_clause() throws RecognitionException { + Set_clauseContext _localctx = new Set_clauseContext(_ctx, getState()); + enterRule(_localctx, 946, RULE_set_clause); + try { + setState(7887); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(7877); + set_target(); + setState(7878); + match(EQUAL); + setState(7879); + a_expr(); + } + break; + case OPEN_PAREN: + enterOuterAlt(_localctx, 2); + { + setState(7881); + match(OPEN_PAREN); + setState(7882); + set_target_list(); + setState(7883); + match(CLOSE_PAREN); + setState(7884); + match(EQUAL); + setState(7885); + a_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Set_targetContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Opt_indirectionContext opt_indirection() { + return getRuleContext(Opt_indirectionContext.class,0); + } + public Set_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_target(this); + } + } + + public final Set_targetContext set_target() throws RecognitionException { + Set_targetContext _localctx = new Set_targetContext(_ctx, getState()); + enterRule(_localctx, 948, RULE_set_target); + try { + enterOuterAlt(_localctx, 1); + { + setState(7889); + colid(); + setState(7890); + opt_indirection(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Set_target_listContext extends ParserRuleContext { + public List set_target() { + return getRuleContexts(Set_targetContext.class); + } + public Set_targetContext set_target(int i) { + return getRuleContext(Set_targetContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Set_target_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_target_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_target_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_target_list(this); + } + } + + public final Set_target_listContext set_target_list() throws RecognitionException { + Set_target_listContext _localctx = new Set_target_listContext(_ctx, getState()); + enterRule(_localctx, 950, RULE_set_target_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7892); + set_target(); + setState(7897); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(7893); + match(COMMA); + setState(7894); + set_target(); + } + } + setState(7899); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DeclarecursorstmtContext extends ParserRuleContext { + public TerminalNode DECLARE() { return getToken(PostgreSqlParser.DECLARE, 0); } + public Cursor_nameContext cursor_name() { + return getRuleContext(Cursor_nameContext.class,0); + } + public Cursor_optionsContext cursor_options() { + return getRuleContext(Cursor_optionsContext.class,0); + } + public TerminalNode CURSOR() { return getToken(PostgreSqlParser.CURSOR, 0); } + public Opt_holdContext opt_hold() { + return getRuleContext(Opt_holdContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public DeclarecursorstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declarecursorstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDeclarecursorstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDeclarecursorstmt(this); + } + } + + public final DeclarecursorstmtContext declarecursorstmt() throws RecognitionException { + DeclarecursorstmtContext _localctx = new DeclarecursorstmtContext(_ctx, getState()); + enterRule(_localctx, 952, RULE_declarecursorstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(7900); + match(DECLARE); + setState(7901); + cursor_name(); + setState(7902); + cursor_options(); + setState(7903); + match(CURSOR); + setState(7904); + opt_hold(); + setState(7905); + match(FOR); + setState(7906); + selectstmt(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cursor_nameContext extends ParserRuleContext { + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Cursor_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cursor_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCursor_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCursor_name(this); + } + } + + public final Cursor_nameContext cursor_name() throws RecognitionException { + Cursor_nameContext _localctx = new Cursor_nameContext(_ctx, getState()); + enterRule(_localctx, 954, RULE_cursor_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(7908); + name(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cursor_optionsContext extends ParserRuleContext { + public List NO() { return getTokens(PostgreSqlParser.NO); } + public TerminalNode NO(int i) { + return getToken(PostgreSqlParser.NO, i); + } + public List SCROLL() { return getTokens(PostgreSqlParser.SCROLL); } + public TerminalNode SCROLL(int i) { + return getToken(PostgreSqlParser.SCROLL, i); + } + public List BINARY() { return getTokens(PostgreSqlParser.BINARY); } + public TerminalNode BINARY(int i) { + return getToken(PostgreSqlParser.BINARY, i); + } + public List INSENSITIVE() { return getTokens(PostgreSqlParser.INSENSITIVE); } + public TerminalNode INSENSITIVE(int i) { + return getToken(PostgreSqlParser.INSENSITIVE, i); + } + public Cursor_optionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cursor_options; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCursor_options(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCursor_options(this); + } + } + + public final Cursor_optionsContext cursor_options() throws RecognitionException { + Cursor_optionsContext _localctx = new Cursor_optionsContext(_ctx, getState()); + enterRule(_localctx, 956, RULE_cursor_options); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7917); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BINARY || _la==INSENSITIVE || _la==NO || _la==SCROLL) { + { + setState(7915); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NO: + { + setState(7910); + match(NO); + setState(7911); + match(SCROLL); + } + break; + case SCROLL: + { + setState(7912); + match(SCROLL); + } + break; + case BINARY: + { + setState(7913); + match(BINARY); + } + break; + case INSENSITIVE: + { + setState(7914); + match(INSENSITIVE); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(7919); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_holdContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode HOLD() { return getToken(PostgreSqlParser.HOLD, 0); } + public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } + public Opt_holdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_hold; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_hold(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_hold(this); + } + } + + public final Opt_holdContext opt_hold() throws RecognitionException { + Opt_holdContext _localctx = new Opt_holdContext(_ctx, getState()); + enterRule(_localctx, 958, RULE_opt_hold); + try { + setState(7925); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + } + break; + case WITH: + enterOuterAlt(_localctx, 2); + { + setState(7921); + match(WITH); + setState(7922); + match(HOLD); + } + break; + case WITHOUT: + enterOuterAlt(_localctx, 3); + { + setState(7923); + match(WITHOUT); + setState(7924); + match(HOLD); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SelectstmtContext extends ParserRuleContext { + public Select_no_parensContext select_no_parens() { + return getRuleContext(Select_no_parensContext.class,0); + } + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public SelectstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectstmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelectstmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelectstmt(this); + } + } + + public final SelectstmtContext selectstmt() throws RecognitionException { + SelectstmtContext _localctx = new SelectstmtContext(_ctx, getState()); + enterRule(_localctx, 960, RULE_selectstmt); + try { + setState(7929); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,416,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7927); + select_no_parens(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7928); + select_with_parens(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Select_with_parensContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Select_no_parensContext select_no_parens() { + return getRuleContext(Select_no_parensContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public Select_with_parensContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_select_with_parens; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_with_parens(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_with_parens(this); + } + } + + public final Select_with_parensContext select_with_parens() throws RecognitionException { + Select_with_parensContext _localctx = new Select_with_parensContext(_ctx, getState()); + enterRule(_localctx, 962, RULE_select_with_parens); + try { + setState(7939); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,417,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(7931); + match(OPEN_PAREN); + setState(7932); + select_no_parens(); + setState(7933); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(7935); + match(OPEN_PAREN); + setState(7936); + select_with_parens(); + setState(7937); + match(CLOSE_PAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Select_no_parensContext extends ParserRuleContext { + public Select_clauseContext select_clause() { + return getRuleContext(Select_clauseContext.class,0); + } + public Opt_sort_clauseContext opt_sort_clause() { + return getRuleContext(Opt_sort_clauseContext.class,0); + } + public For_locking_clauseContext for_locking_clause() { + return getRuleContext(For_locking_clauseContext.class,0); + } + public Opt_select_limitContext opt_select_limit() { + return getRuleContext(Opt_select_limitContext.class,0); + } + public Select_limitContext select_limit() { + return getRuleContext(Select_limitContext.class,0); + } + public Opt_for_locking_clauseContext opt_for_locking_clause() { + return getRuleContext(Opt_for_locking_clauseContext.class,0); + } + public With_clauseContext with_clause() { + return getRuleContext(With_clauseContext.class,0); + } + public Select_no_parensContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_select_no_parens; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_no_parens(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_no_parens(this); + } + } + + public final Select_no_parensContext select_no_parens() throws RecognitionException { + Select_no_parensContext _localctx = new Select_no_parensContext(_ctx, getState()); + enterRule(_localctx, 964, RULE_select_no_parens); + try { + setState(7962); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case SELECT: + case TABLE: + case VALUES: + enterOuterAlt(_localctx, 1); + { + setState(7941); + select_clause(); + setState(7942); + opt_sort_clause(); + setState(7949); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,418,_ctx) ) { + case 1: + { + setState(7943); + for_locking_clause(); + setState(7944); + opt_select_limit(); + } + break; + case 2: + { + setState(7946); + select_limit(); + setState(7947); + opt_for_locking_clause(); + } + break; + } + } + break; + case WITH: + enterOuterAlt(_localctx, 2); + { + setState(7951); + with_clause(); + setState(7952); + select_clause(); + setState(7953); + opt_sort_clause(); + setState(7960); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,419,_ctx) ) { + case 1: + { + setState(7954); + for_locking_clause(); + setState(7955); + opt_select_limit(); + } + break; + case 2: + { + setState(7957); + select_limit(); + setState(7958); + opt_for_locking_clause(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Select_clauseContext extends ParserRuleContext { + public List simple_select_intersect() { + return getRuleContexts(Simple_select_intersectContext.class); + } + public Simple_select_intersectContext simple_select_intersect(int i) { + return getRuleContext(Simple_select_intersectContext.class,i); + } + public List all_or_distinct() { + return getRuleContexts(All_or_distinctContext.class); + } + public All_or_distinctContext all_or_distinct(int i) { + return getRuleContext(All_or_distinctContext.class,i); + } + public List UNION() { return getTokens(PostgreSqlParser.UNION); } + public TerminalNode UNION(int i) { + return getToken(PostgreSqlParser.UNION, i); + } + public List EXCEPT() { return getTokens(PostgreSqlParser.EXCEPT); } + public TerminalNode EXCEPT(int i) { + return getToken(PostgreSqlParser.EXCEPT, i); + } + public Select_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_select_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_clause(this); + } + } + + public final Select_clauseContext select_clause() throws RecognitionException { + Select_clauseContext _localctx = new Select_clauseContext(_ctx, getState()); + enterRule(_localctx, 966, RULE_select_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7964); + simple_select_intersect(); + setState(7971); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==EXCEPT || _la==UNION) { + { + { + setState(7965); + _la = _input.LA(1); + if ( !(_la==EXCEPT || _la==UNION) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(7966); + all_or_distinct(); + setState(7967); + simple_select_intersect(); + } + } + setState(7973); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Simple_select_intersectContext extends ParserRuleContext { + public List simple_select_pramary() { + return getRuleContexts(Simple_select_pramaryContext.class); + } + public Simple_select_pramaryContext simple_select_pramary(int i) { + return getRuleContext(Simple_select_pramaryContext.class,i); + } + public List INTERSECT() { return getTokens(PostgreSqlParser.INTERSECT); } + public TerminalNode INTERSECT(int i) { + return getToken(PostgreSqlParser.INTERSECT, i); + } + public List all_or_distinct() { + return getRuleContexts(All_or_distinctContext.class); + } + public All_or_distinctContext all_or_distinct(int i) { + return getRuleContext(All_or_distinctContext.class,i); + } + public Simple_select_intersectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simple_select_intersect; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSimple_select_intersect(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSimple_select_intersect(this); + } + } + + public final Simple_select_intersectContext simple_select_intersect() throws RecognitionException { + Simple_select_intersectContext _localctx = new Simple_select_intersectContext(_ctx, getState()); + enterRule(_localctx, 968, RULE_simple_select_intersect); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(7974); + simple_select_pramary(); + setState(7981); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==INTERSECT) { + { + { + setState(7975); + match(INTERSECT); + setState(7976); + all_or_distinct(); + setState(7977); + simple_select_pramary(); + } + } + setState(7983); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Simple_select_pramaryContext extends ParserRuleContext { + public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } + public List into_clause() { + return getRuleContexts(Into_clauseContext.class); + } + public Into_clauseContext into_clause(int i) { + return getRuleContext(Into_clauseContext.class,i); + } + public From_clauseContext from_clause() { + return getRuleContext(From_clauseContext.class,0); + } + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class,0); + } + public Group_clauseContext group_clause() { + return getRuleContext(Group_clauseContext.class,0); + } + public Having_clauseContext having_clause() { + return getRuleContext(Having_clauseContext.class,0); + } + public Window_clauseContext window_clause() { + return getRuleContext(Window_clauseContext.class,0); + } + public Opt_all_clauseContext opt_all_clause() { + return getRuleContext(Opt_all_clauseContext.class,0); + } + public Opt_target_listContext opt_target_list() { + return getRuleContext(Opt_target_listContext.class,0); + } + public Distinct_clauseContext distinct_clause() { + return getRuleContext(Distinct_clauseContext.class,0); + } + public Target_listContext target_list() { + return getRuleContext(Target_listContext.class,0); + } + public Top_clauseContext top_clause() { + return getRuleContext(Top_clauseContext.class,0); + } + public Values_clauseContext values_clause() { + return getRuleContext(Values_clauseContext.class,0); + } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Relation_exprContext relation_expr() { + return getRuleContext(Relation_exprContext.class,0); + } + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public Simple_select_pramaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simple_select_pramary; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSimple_select_pramary(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSimple_select_pramary(this); + } + } + + public final Simple_select_pramaryContext simple_select_pramary() throws RecognitionException { + Simple_select_pramaryContext _localctx = new Simple_select_pramaryContext(_ctx, getState()); + enterRule(_localctx, 970, RULE_simple_select_pramary); + try { + setState(8008); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + enterOuterAlt(_localctx, 1); + { + { + setState(7984); + match(SELECT); + setState(7995); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case COLON: + case QUESTION: + case STAR: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case ALL: + case ANALYSE: + case ANALYZE: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CREATE: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case EXCEPT: + case FALSE_P: + case FETCH: + case FOR: + case FROM: + case GRANT: + case GROUP_P: + case HAVING: + case INTERSECT: + case INTO: + case LIMIT: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case OFFSET: + case ON: + case ORDER: + case RETURNING: + case SELECT: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNION: + case UNIQUE: + case USER: + case WHERE: + case WINDOW: + case WITH: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MERGE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case END_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case LOOP: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case MetaCommand: + case EscapeStringConstant: + { + setState(7985); + opt_all_clause(); + setState(7986); + into_clause(); + setState(7987); + opt_target_list(); + } + break; + case DISTINCT: + { + setState(7989); + distinct_clause(); + setState(7990); + target_list(); + } + break; + case TOP: + { + setState(7992); + top_clause(); + setState(7993); + opt_target_list(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(7997); + into_clause(); + setState(7998); + from_clause(); + setState(7999); + where_clause(); + setState(8000); + group_clause(); + setState(8001); + having_clause(); + setState(8002); + window_clause(); + } + } + break; + case VALUES: + enterOuterAlt(_localctx, 2); + { + setState(8004); + values_clause(); + } + break; + case TABLE: + enterOuterAlt(_localctx, 3); + { + setState(8005); + match(TABLE); + setState(8006); + relation_expr(); + } + break; + case OPEN_PAREN: + enterOuterAlt(_localctx, 4); + { + setState(8007); + select_with_parens(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Top_clauseContext extends ParserRuleContext { + public TerminalNode TOP() { return getToken(PostgreSqlParser.TOP, 0); } + public TerminalNode Integral() { return getToken(PostgreSqlParser.Integral, 0); } + public Top_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_top_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTop_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTop_clause(this); + } + } + + public final Top_clauseContext top_clause() throws RecognitionException { + Top_clauseContext _localctx = new Top_clauseContext(_ctx, getState()); + enterRule(_localctx, 972, RULE_top_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(8010); + match(TOP); + setState(8011); + match(Integral); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class With_clauseContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public Cte_listContext cte_list() { + return getRuleContext(Cte_listContext.class,0); + } + public TerminalNode RECURSIVE() { return getToken(PostgreSqlParser.RECURSIVE, 0); } + public With_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_with_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWith_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWith_clause(this); + } + } + + public final With_clauseContext with_clause() throws RecognitionException { + With_clauseContext _localctx = new With_clauseContext(_ctx, getState()); + enterRule(_localctx, 974, RULE_with_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(8013); + match(WITH); + setState(8015); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,425,_ctx) ) { + case 1: + { + setState(8014); + match(RECURSIVE); + } + break; + } + setState(8017); + cte_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cte_listContext extends ParserRuleContext { + public List common_table_expr() { + return getRuleContexts(Common_table_exprContext.class); + } + public Common_table_exprContext common_table_expr(int i) { + return getRuleContext(Common_table_exprContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Cte_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cte_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCte_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCte_list(this); + } + } + + public final Cte_listContext cte_list() throws RecognitionException { + Cte_listContext _localctx = new Cte_listContext(_ctx, getState()); + enterRule(_localctx, 976, RULE_cte_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8019); + common_table_expr(); + setState(8024); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(8020); + match(COMMA); + setState(8021); + common_table_expr(); + } + } + setState(8026); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Common_table_exprContext extends ParserRuleContext { + public NameContext name() { + return getRuleContext(NameContext.class,0); + } + public Opt_name_listContext opt_name_list() { + return getRuleContext(Opt_name_listContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public Opt_materializedContext opt_materialized() { + return getRuleContext(Opt_materializedContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public PreparablestmtContext preparablestmt() { + return getRuleContext(PreparablestmtContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Common_table_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_common_table_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCommon_table_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCommon_table_expr(this); + } + } + + public final Common_table_exprContext common_table_expr() throws RecognitionException { + Common_table_exprContext _localctx = new Common_table_exprContext(_ctx, getState()); + enterRule(_localctx, 978, RULE_common_table_expr); + try { + enterOuterAlt(_localctx, 1); + { + setState(8027); + name(); + setState(8028); + opt_name_list(); + setState(8029); + match(AS); + setState(8030); + opt_materialized(); + setState(8031); + match(OPEN_PAREN); + setState(8032); + preparablestmt(); + setState(8033); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_materializedContext extends ParserRuleContext { + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public Opt_materializedContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_materialized; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_materialized(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_materialized(this); + } + } + + public final Opt_materializedContext opt_materialized() throws RecognitionException { + Opt_materializedContext _localctx = new Opt_materializedContext(_ctx, getState()); + enterRule(_localctx, 980, RULE_opt_materialized); + try { + setState(8039); + _errHandler.sync(this); + switch (_input.LA(1)) { + case MATERIALIZED: + enterOuterAlt(_localctx, 1); + { + setState(8035); + match(MATERIALIZED); + } + break; + case NOT: + enterOuterAlt(_localctx, 2); + { + setState(8036); + match(NOT); + setState(8037); + match(MATERIALIZED); + } + break; + case OPEN_PAREN: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_with_clauseContext extends ParserRuleContext { + public With_clauseContext with_clause() { + return getRuleContext(With_clauseContext.class,0); + } + public Opt_with_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_with_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_with_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_with_clause(this); + } + } + + public final Opt_with_clauseContext opt_with_clause() throws RecognitionException { + Opt_with_clauseContext _localctx = new Opt_with_clauseContext(_ctx, getState()); + enterRule(_localctx, 982, RULE_opt_with_clause); + try { + setState(8043); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WITH: + enterOuterAlt(_localctx, 1); + { + setState(8041); + with_clause(); + } + break; + case DELETE_P: + case INSERT: + case UPDATE: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Into_clauseContext extends ParserRuleContext { + public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } + public Opt_strictContext opt_strict() { + return getRuleContext(Opt_strictContext.class,0); + } + public OpttempTableNameContext opttempTableName() { + return getRuleContext(OpttempTableNameContext.class,0); + } + public Into_targetContext into_target() { + return getRuleContext(Into_targetContext.class,0); + } + public Into_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_into_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInto_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInto_clause(this); + } + } + + public final Into_clauseContext into_clause() throws RecognitionException { + Into_clauseContext _localctx = new Into_clauseContext(_ctx, getState()); + enterRule(_localctx, 984, RULE_into_clause); + try { + setState(8053); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,430,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8045); + match(INTO); + setState(8050); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,429,_ctx) ) { + case 1: + { + setState(8046); + opt_strict(); + setState(8047); + opttempTableName(); + } + break; + case 2: + { + setState(8049); + into_target(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_strictContext extends ParserRuleContext { + public TerminalNode STRICT_P() { return getToken(PostgreSqlParser.STRICT_P, 0); } + public Opt_strictContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_strict; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_strict(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_strict(this); + } + } + + public final Opt_strictContext opt_strict() throws RecognitionException { + Opt_strictContext _localctx = new Opt_strictContext(_ctx, getState()); + enterRule(_localctx, 986, RULE_opt_strict); + try { + setState(8057); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,431,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8056); + match(STRICT_P); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OpttempTableNameContext extends ParserRuleContext { + public Opt_tableContext opt_table() { + return getRuleContext(Opt_tableContext.class,0); + } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } + public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } + public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } + public TerminalNode GLOBAL() { return getToken(PostgreSqlParser.GLOBAL, 0); } + public TerminalNode UNLOGGED() { return getToken(PostgreSqlParser.UNLOGGED, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public OpttempTableNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opttempTableName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpttempTableName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpttempTableName(this); + } + } + + public final OpttempTableNameContext opttempTableName() throws RecognitionException { + OpttempTableNameContext _localctx = new OpttempTableNameContext(_ctx, getState()); + enterRule(_localctx, 988, RULE_opttempTableName); + int _la; + try { + setState(8073); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,433,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8060); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==GLOBAL || _la==LOCAL) { + { + setState(8059); + _la = _input.LA(1); + if ( !(_la==GLOBAL || _la==LOCAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(8062); + _la = _input.LA(1); + if ( !(_la==TEMP || _la==TEMPORARY) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8063); + opt_table(); + setState(8064); + qualified_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8066); + match(UNLOGGED); + setState(8067); + opt_table(); + setState(8068); + qualified_name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(8070); + match(TABLE); + setState(8071); + qualified_name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(8072); + qualified_name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_tableContext extends ParserRuleContext { + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public Opt_tableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_table; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_table(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_table(this); + } + } + + public final Opt_tableContext opt_table() throws RecognitionException { + Opt_tableContext _localctx = new Opt_tableContext(_ctx, getState()); + enterRule(_localctx, 990, RULE_opt_table); + try { + setState(8077); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,434,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8075); + match(TABLE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class All_or_distinctContext extends ParserRuleContext { + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } + public All_or_distinctContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_all_or_distinct; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAll_or_distinct(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAll_or_distinct(this); + } + } + + public final All_or_distinctContext all_or_distinct() throws RecognitionException { + All_or_distinctContext _localctx = new All_or_distinctContext(_ctx, getState()); + enterRule(_localctx, 992, RULE_all_or_distinct); + try { + setState(8082); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALL: + enterOuterAlt(_localctx, 1); + { + setState(8079); + match(ALL); + } + break; + case DISTINCT: + enterOuterAlt(_localctx, 2); + { + setState(8080); + match(DISTINCT); + } + break; + case OPEN_PAREN: + case SELECT: + case TABLE: + case VALUES: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Distinct_clauseContext extends ParserRuleContext { + public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Distinct_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_distinct_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDistinct_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDistinct_clause(this); + } + } + + public final Distinct_clauseContext distinct_clause() throws RecognitionException { + Distinct_clauseContext _localctx = new Distinct_clauseContext(_ctx, getState()); + enterRule(_localctx, 994, RULE_distinct_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8084); + match(DISTINCT); + setState(8090); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ON) { + { + setState(8085); + match(ON); + setState(8086); + match(OPEN_PAREN); + setState(8087); + expr_list(); + setState(8088); + match(CLOSE_PAREN); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_all_clauseContext extends ParserRuleContext { + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public Opt_all_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_all_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_all_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_all_clause(this); + } + } + + public final Opt_all_clauseContext opt_all_clause() throws RecognitionException { + Opt_all_clauseContext _localctx = new Opt_all_clauseContext(_ctx, getState()); + enterRule(_localctx, 996, RULE_opt_all_clause); + try { + setState(8094); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALL: + enterOuterAlt(_localctx, 1); + { + setState(8092); + match(ALL); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case COLON: + case QUESTION: + case STAR: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case ANALYSE: + case ANALYZE: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CREATE: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case EXCEPT: + case FALSE_P: + case FETCH: + case FOR: + case FROM: + case GRANT: + case GROUP_P: + case HAVING: + case INTERSECT: + case INTO: + case LIMIT: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case OFFSET: + case ON: + case ORDER: + case RETURNING: + case SELECT: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNION: + case UNIQUE: + case USER: + case WHERE: + case WINDOW: + case WITH: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MERGE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case END_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case LOOP: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case MetaCommand: + case EscapeStringConstant: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_sort_clauseContext extends ParserRuleContext { + public Sort_clauseContext sort_clause() { + return getRuleContext(Sort_clauseContext.class,0); + } + public Opt_sort_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_sort_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_sort_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_sort_clause(this); + } + } + + public final Opt_sort_clauseContext opt_sort_clause() throws RecognitionException { + Opt_sort_clauseContext _localctx = new Opt_sort_clauseContext(_ctx, getState()); + enterRule(_localctx, 998, RULE_opt_sort_clause); + try { + setState(8098); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ORDER: + enterOuterAlt(_localctx, 1); + { + setState(8096); + sort_clause(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case FOR: + case GRANT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case RETURNING: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case RANGE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case ROWS: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case GROUPS: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Sort_clauseContext extends ParserRuleContext { + public TerminalNode ORDER() { return getToken(PostgreSqlParser.ORDER, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Sortby_listContext sortby_list() { + return getRuleContext(Sortby_listContext.class,0); + } + public Sort_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sort_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSort_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSort_clause(this); + } + } + + public final Sort_clauseContext sort_clause() throws RecognitionException { + Sort_clauseContext _localctx = new Sort_clauseContext(_ctx, getState()); + enterRule(_localctx, 1000, RULE_sort_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(8100); + match(ORDER); + setState(8101); + match(BY); + setState(8102); + sortby_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Sortby_listContext extends ParserRuleContext { + public List sortby() { + return getRuleContexts(SortbyContext.class); + } + public SortbyContext sortby(int i) { + return getRuleContext(SortbyContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Sortby_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sortby_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSortby_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSortby_list(this); + } + } + + public final Sortby_listContext sortby_list() throws RecognitionException { + Sortby_listContext _localctx = new Sortby_listContext(_ctx, getState()); + enterRule(_localctx, 1002, RULE_sortby_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8104); + sortby(); + setState(8109); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(8105); + match(COMMA); + setState(8106); + sortby(); + } + } + setState(8111); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SortbyContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Opt_nulls_orderContext opt_nulls_order() { + return getRuleContext(Opt_nulls_orderContext.class,0); + } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public Qual_all_opContext qual_all_op() { + return getRuleContext(Qual_all_opContext.class,0); + } + public Opt_asc_descContext opt_asc_desc() { + return getRuleContext(Opt_asc_descContext.class,0); + } + public SortbyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sortby; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSortby(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSortby(this); + } + } + + public final SortbyContext sortby() throws RecognitionException { + SortbyContext _localctx = new SortbyContext(_ctx, getState()); + enterRule(_localctx, 1004, RULE_sortby); + try { + enterOuterAlt(_localctx, 1); + { + setState(8112); + a_expr(); + setState(8116); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + { + setState(8113); + match(USING); + setState(8114); + qual_all_op(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case ASC: + case CREATE: + case DESC: + case DO: + case FETCH: + case FOR: + case GRANT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case RETURNING: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case NULLS_P: + case PREPARE: + case RANGE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case ROWS: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case GROUPS: + case LOOP: + case MetaCommand: + { + setState(8115); + opt_asc_desc(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(8118); + opt_nulls_order(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Select_limitContext extends ParserRuleContext { + public Limit_clauseContext limit_clause() { + return getRuleContext(Limit_clauseContext.class,0); + } + public Offset_clauseContext offset_clause() { + return getRuleContext(Offset_clauseContext.class,0); + } + public Select_limitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_select_limit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_limit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_limit(this); + } + } + + public final Select_limitContext select_limit() throws RecognitionException { + Select_limitContext _localctx = new Select_limitContext(_ctx, getState()); + enterRule(_localctx, 1006, RULE_select_limit); + int _la; + try { + setState(8128); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FETCH: + case LIMIT: + enterOuterAlt(_localctx, 1); + { + setState(8120); + limit_clause(); + setState(8122); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OFFSET) { + { + setState(8121); + offset_clause(); + } + } + + } + break; + case OFFSET: + enterOuterAlt(_localctx, 2); + { + setState(8124); + offset_clause(); + setState(8126); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,442,_ctx) ) { + case 1: + { + setState(8125); + limit_clause(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_select_limitContext extends ParserRuleContext { + public Select_limitContext select_limit() { + return getRuleContext(Select_limitContext.class,0); + } + public Opt_select_limitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_select_limit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_select_limit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_select_limit(this); + } + } + + public final Opt_select_limitContext opt_select_limit() throws RecognitionException { + Opt_select_limitContext _localctx = new Opt_select_limitContext(_ctx, getState()); + enterRule(_localctx, 1008, RULE_opt_select_limit); + try { + setState(8132); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,444,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8130); + select_limit(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Limit_clauseContext extends ParserRuleContext { + public TerminalNode LIMIT() { return getToken(PostgreSqlParser.LIMIT, 0); } + public Select_limit_valueContext select_limit_value() { + return getRuleContext(Select_limit_valueContext.class,0); + } + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public Select_offset_valueContext select_offset_value() { + return getRuleContext(Select_offset_valueContext.class,0); + } + public TerminalNode FETCH() { return getToken(PostgreSqlParser.FETCH, 0); } + public First_or_nextContext first_or_next() { + return getRuleContext(First_or_nextContext.class,0); + } + public Select_fetch_first_valueContext select_fetch_first_value() { + return getRuleContext(Select_fetch_first_valueContext.class,0); + } + public Row_or_rowsContext row_or_rows() { + return getRuleContext(Row_or_rowsContext.class,0); + } + public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode TIES() { return getToken(PostgreSqlParser.TIES, 0); } + public Limit_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_limit_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLimit_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLimit_clause(this); + } + } + + public final Limit_clauseContext limit_clause() throws RecognitionException { + Limit_clauseContext _localctx = new Limit_clauseContext(_ctx, getState()); + enterRule(_localctx, 1010, RULE_limit_clause); + int _la; + try { + setState(8157); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LIMIT: + enterOuterAlt(_localctx, 1); + { + setState(8134); + match(LIMIT); + setState(8135); + select_limit_value(); + setState(8138); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(8136); + match(COMMA); + setState(8137); + select_offset_value(); + } + } + + } + break; + case FETCH: + enterOuterAlt(_localctx, 2); + { + setState(8140); + match(FETCH); + setState(8141); + first_or_next(); + setState(8155); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,448,_ctx) ) { + case 1: + { + setState(8142); + select_fetch_first_value(); + setState(8143); + row_or_rows(); + setState(8147); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ONLY: + { + setState(8144); + match(ONLY); + } + break; + case WITH: + { + setState(8145); + match(WITH); + setState(8146); + match(TIES); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + { + setState(8149); + row_or_rows(); + setState(8153); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ONLY: + { + setState(8150); + match(ONLY); + } + break; + case WITH: + { + setState(8151); + match(WITH); + setState(8152); + match(TIES); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Offset_clauseContext extends ParserRuleContext { + public TerminalNode OFFSET() { return getToken(PostgreSqlParser.OFFSET, 0); } + public Select_offset_valueContext select_offset_value() { + return getRuleContext(Select_offset_valueContext.class,0); + } + public Select_fetch_first_valueContext select_fetch_first_value() { + return getRuleContext(Select_fetch_first_valueContext.class,0); + } + public Row_or_rowsContext row_or_rows() { + return getRuleContext(Row_or_rowsContext.class,0); + } + public Offset_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_offset_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOffset_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOffset_clause(this); + } + } + + public final Offset_clauseContext offset_clause() throws RecognitionException { + Offset_clauseContext _localctx = new Offset_clauseContext(_ctx, getState()); + enterRule(_localctx, 1012, RULE_offset_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(8159); + match(OFFSET); + setState(8164); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,450,_ctx) ) { + case 1: + { + setState(8160); + select_offset_value(); + } + break; + case 2: + { + setState(8161); + select_fetch_first_value(); + setState(8162); + row_or_rows(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Select_limit_valueContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public Select_limit_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_select_limit_value; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_limit_value(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_limit_value(this); + } + } + + public final Select_limit_valueContext select_limit_value() throws RecognitionException { + Select_limit_valueContext _localctx = new Select_limit_valueContext(_ctx, getState()); + enterRule(_localctx, 1014, RULE_select_limit_value); + try { + setState(8168); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case COLON: + case QUESTION: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNIQUE: + case USER: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(8166); + a_expr(); + } + break; + case ALL: + enterOuterAlt(_localctx, 2); + { + setState(8167); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Select_offset_valueContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Select_offset_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_select_offset_value; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_offset_value(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_offset_value(this); + } + } + + public final Select_offset_valueContext select_offset_value() throws RecognitionException { + Select_offset_valueContext _localctx = new Select_offset_valueContext(_ctx, getState()); + enterRule(_localctx, 1016, RULE_select_offset_value); + try { + enterOuterAlt(_localctx, 1); + { + setState(8170); + a_expr(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Select_fetch_first_valueContext extends ParserRuleContext { + public C_exprContext c_expr() { + return getRuleContext(C_exprContext.class,0); + } + public TerminalNode PLUS() { return getToken(PostgreSqlParser.PLUS, 0); } + public I_or_f_constContext i_or_f_const() { + return getRuleContext(I_or_f_constContext.class,0); + } + public TerminalNode MINUS() { return getToken(PostgreSqlParser.MINUS, 0); } + public Select_fetch_first_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_select_fetch_first_value; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSelect_fetch_first_value(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSelect_fetch_first_value(this); + } + } + + public final Select_fetch_first_valueContext select_fetch_first_value() throws RecognitionException { + Select_fetch_first_valueContext _localctx = new Select_fetch_first_valueContext(_ctx, getState()); + enterRule(_localctx, 1018, RULE_select_fetch_first_value); + try { + setState(8177); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case COLON: + case QUESTION: + case PARAM: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case LOCALTIME: + case LOCALTIMESTAMP: + case NULL_P: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNIQUE: + case USER: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(8172); + c_expr(); + } + break; + case PLUS: + enterOuterAlt(_localctx, 2); + { + setState(8173); + match(PLUS); + setState(8174); + i_or_f_const(); + } + break; + case MINUS: + enterOuterAlt(_localctx, 3); + { + setState(8175); + match(MINUS); + setState(8176); + i_or_f_const(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class I_or_f_constContext extends ParserRuleContext { + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public FconstContext fconst() { + return getRuleContext(FconstContext.class,0); + } + public I_or_f_constContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_i_or_f_const; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterI_or_f_const(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitI_or_f_const(this); + } + } + + public final I_or_f_constContext i_or_f_const() throws RecognitionException { + I_or_f_constContext _localctx = new I_or_f_constContext(_ctx, getState()); + enterRule(_localctx, 1020, RULE_i_or_f_const); + try { + setState(8181); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Integral: + enterOuterAlt(_localctx, 1); + { + setState(8179); + iconst(); + } + break; + case Numeric: + enterOuterAlt(_localctx, 2); + { + setState(8180); + fconst(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Row_or_rowsContext extends ParserRuleContext { + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } + public Row_or_rowsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_row_or_rows; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRow_or_rows(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRow_or_rows(this); + } + } + + public final Row_or_rowsContext row_or_rows() throws RecognitionException { + Row_or_rowsContext _localctx = new Row_or_rowsContext(_ctx, getState()); + enterRule(_localctx, 1022, RULE_row_or_rows); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8183); + _la = _input.LA(1); + if ( !(_la==ROWS || _la==ROW) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class First_or_nextContext extends ParserRuleContext { + public TerminalNode FIRST_P() { return getToken(PostgreSqlParser.FIRST_P, 0); } + public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } + public First_or_nextContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_first_or_next; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFirst_or_next(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFirst_or_next(this); + } + } + + public final First_or_nextContext first_or_next() throws RecognitionException { + First_or_nextContext _localctx = new First_or_nextContext(_ctx, getState()); + enterRule(_localctx, 1024, RULE_first_or_next); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8185); + _la = _input.LA(1); + if ( !(_la==FIRST_P || _la==NEXT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Group_clauseContext extends ParserRuleContext { + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Group_by_listContext group_by_list() { + return getRuleContext(Group_by_listContext.class,0); + } + public Group_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_group_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGroup_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGroup_clause(this); + } + } + + public final Group_clauseContext group_clause() throws RecognitionException { + Group_clauseContext _localctx = new Group_clauseContext(_ctx, getState()); + enterRule(_localctx, 1026, RULE_group_clause); + try { + setState(8191); + _errHandler.sync(this); + switch (_input.LA(1)) { + case GROUP_P: + enterOuterAlt(_localctx, 1); + { + setState(8187); + match(GROUP_P); + setState(8188); + match(BY); + setState(8189); + group_by_list(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case EXCEPT: + case FETCH: + case FOR: + case GRANT: + case HAVING: + case INTERSECT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case ORDER: + case RETURNING: + case SELECT: + case TABLE: + case THEN: + case UNION: + case USING: + case WHEN: + case WINDOW: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Group_by_listContext extends ParserRuleContext { + public List group_by_item() { + return getRuleContexts(Group_by_itemContext.class); + } + public Group_by_itemContext group_by_item(int i) { + return getRuleContext(Group_by_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Group_by_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_group_by_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGroup_by_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGroup_by_list(this); + } + } + + public final Group_by_listContext group_by_list() throws RecognitionException { + Group_by_listContext _localctx = new Group_by_listContext(_ctx, getState()); + enterRule(_localctx, 1028, RULE_group_by_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8193); + group_by_item(); + setState(8198); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,455,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8194); + match(COMMA); + setState(8195); + group_by_item(); + } + } + } + setState(8200); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,455,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Group_by_itemContext extends ParserRuleContext { + public Empty_grouping_setContext empty_grouping_set() { + return getRuleContext(Empty_grouping_setContext.class,0); + } + public Cube_clauseContext cube_clause() { + return getRuleContext(Cube_clauseContext.class,0); + } + public Rollup_clauseContext rollup_clause() { + return getRuleContext(Rollup_clauseContext.class,0); + } + public Grouping_sets_clauseContext grouping_sets_clause() { + return getRuleContext(Grouping_sets_clauseContext.class,0); + } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Group_by_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_group_by_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGroup_by_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGroup_by_item(this); + } + } + + public final Group_by_itemContext group_by_item() throws RecognitionException { + Group_by_itemContext _localctx = new Group_by_itemContext(_ctx, getState()); + enterRule(_localctx, 1030, RULE_group_by_item); + try { + setState(8206); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,456,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8201); + empty_grouping_set(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8202); + cube_clause(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(8203); + rollup_clause(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(8204); + grouping_sets_clause(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(8205); + a_expr(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Empty_grouping_setContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Empty_grouping_setContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_empty_grouping_set; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterEmpty_grouping_set(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitEmpty_grouping_set(this); + } + } + + public final Empty_grouping_setContext empty_grouping_set() throws RecognitionException { + Empty_grouping_setContext _localctx = new Empty_grouping_setContext(_ctx, getState()); + enterRule(_localctx, 1032, RULE_empty_grouping_set); + try { + enterOuterAlt(_localctx, 1); + { + setState(8208); + match(OPEN_PAREN); + setState(8209); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Rollup_clauseContext extends ParserRuleContext { + public TerminalNode ROLLUP() { return getToken(PostgreSqlParser.ROLLUP, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Rollup_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rollup_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRollup_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRollup_clause(this); + } + } + + public final Rollup_clauseContext rollup_clause() throws RecognitionException { + Rollup_clauseContext _localctx = new Rollup_clauseContext(_ctx, getState()); + enterRule(_localctx, 1034, RULE_rollup_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(8211); + match(ROLLUP); + setState(8212); + match(OPEN_PAREN); + setState(8213); + expr_list(); + setState(8214); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cube_clauseContext extends ParserRuleContext { + public TerminalNode CUBE() { return getToken(PostgreSqlParser.CUBE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Cube_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cube_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCube_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCube_clause(this); + } + } + + public final Cube_clauseContext cube_clause() throws RecognitionException { + Cube_clauseContext _localctx = new Cube_clauseContext(_ctx, getState()); + enterRule(_localctx, 1036, RULE_cube_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(8216); + match(CUBE); + setState(8217); + match(OPEN_PAREN); + setState(8218); + expr_list(); + setState(8219); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Grouping_sets_clauseContext extends ParserRuleContext { + public TerminalNode GROUPING() { return getToken(PostgreSqlParser.GROUPING, 0); } + public TerminalNode SETS() { return getToken(PostgreSqlParser.SETS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Group_by_listContext group_by_list() { + return getRuleContext(Group_by_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Grouping_sets_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grouping_sets_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrouping_sets_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrouping_sets_clause(this); + } + } + + public final Grouping_sets_clauseContext grouping_sets_clause() throws RecognitionException { + Grouping_sets_clauseContext _localctx = new Grouping_sets_clauseContext(_ctx, getState()); + enterRule(_localctx, 1038, RULE_grouping_sets_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(8221); + match(GROUPING); + setState(8222); + match(SETS); + setState(8223); + match(OPEN_PAREN); + setState(8224); + group_by_list(); + setState(8225); match(CLOSE_PAREN); } } @@ -35071,15 +65403,8 @@ public class PostgreSqlParser extends Parser { @SuppressWarnings("CheckReturnValue") public static class Having_clauseContext extends ParserRuleContext { public TerminalNode HAVING() { return getToken(PostgreSqlParser.HAVING, 0); } - public List predicate() { - return getRuleContexts(PredicateContext.class); - } - public PredicateContext predicate(int i) { - return getRuleContext(PredicateContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); } public Having_clauseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -35097,32 +65422,464 @@ public class PostgreSqlParser extends Parser { public final Having_clauseContext having_clause() throws RecognitionException { Having_clauseContext _localctx = new Having_clauseContext(_ctx, getState()); - enterRule(_localctx, 394, RULE_having_clause); + enterRule(_localctx, 1040, RULE_having_clause); + try { + setState(8230); + _errHandler.sync(this); + switch (_input.LA(1)) { + case HAVING: + enterOuterAlt(_localctx, 1); + { + setState(8227); + match(HAVING); + setState(8228); + a_expr(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case EXCEPT: + case FETCH: + case FOR: + case GRANT: + case INTERSECT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case ORDER: + case RETURNING: + case SELECT: + case TABLE: + case THEN: + case UNION: + case USING: + case WHEN: + case WINDOW: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_locking_clauseContext extends ParserRuleContext { + public For_locking_itemsContext for_locking_items() { + return getRuleContext(For_locking_itemsContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode READ() { return getToken(PostgreSqlParser.READ, 0); } + public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } + public For_locking_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for_locking_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFor_locking_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFor_locking_clause(this); + } + } + + public final For_locking_clauseContext for_locking_clause() throws RecognitionException { + For_locking_clauseContext _localctx = new For_locking_clauseContext(_ctx, getState()); + enterRule(_localctx, 1042, RULE_for_locking_clause); + try { + setState(8236); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,458,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8232); + for_locking_items(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8233); + match(FOR); + setState(8234); + match(READ); + setState(8235); + match(ONLY); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_for_locking_clauseContext extends ParserRuleContext { + public For_locking_clauseContext for_locking_clause() { + return getRuleContext(For_locking_clauseContext.class,0); + } + public Opt_for_locking_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_for_locking_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_for_locking_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_for_locking_clause(this); + } + } + + public final Opt_for_locking_clauseContext opt_for_locking_clause() throws RecognitionException { + Opt_for_locking_clauseContext _localctx = new Opt_for_locking_clauseContext(_ctx, getState()); + enterRule(_localctx, 1044, RULE_opt_for_locking_clause); + try { + setState(8240); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(8238); + for_locking_clause(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case ON: + case RETURNING: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_locking_itemsContext extends ParserRuleContext { + public List for_locking_item() { + return getRuleContexts(For_locking_itemContext.class); + } + public For_locking_itemContext for_locking_item(int i) { + return getRuleContext(For_locking_itemContext.class,i); + } + public For_locking_itemsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for_locking_items; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFor_locking_items(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFor_locking_items(this); + } + } + + public final For_locking_itemsContext for_locking_items() throws RecognitionException { + For_locking_itemsContext _localctx = new For_locking_itemsContext(_ctx, getState()); + enterRule(_localctx, 1046, RULE_for_locking_items); + int _la; try { - int _alt; enterOuterAlt(_localctx, 1); { - setState(4390); - match(HAVING); - setState(4391); - predicate(0); - setState(4396); + setState(8243); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,509,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(4392); - match(COMMA); - setState(4393); - predicate(0); - } - } + _la = _input.LA(1); + do { + { + { + setState(8242); + for_locking_item(); } - setState(4398); + } + setState(8245); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,509,_ctx); + _la = _input.LA(1); + } while ( _la==FOR ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_locking_itemContext extends ParserRuleContext { + public For_locking_strengthContext for_locking_strength() { + return getRuleContext(For_locking_strengthContext.class,0); + } + public Locked_rels_listContext locked_rels_list() { + return getRuleContext(Locked_rels_listContext.class,0); + } + public Opt_nowait_or_skipContext opt_nowait_or_skip() { + return getRuleContext(Opt_nowait_or_skipContext.class,0); + } + public For_locking_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for_locking_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFor_locking_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFor_locking_item(this); + } + } + + public final For_locking_itemContext for_locking_item() throws RecognitionException { + For_locking_itemContext _localctx = new For_locking_itemContext(_ctx, getState()); + enterRule(_localctx, 1048, RULE_for_locking_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(8247); + for_locking_strength(); + setState(8248); + locked_rels_list(); + setState(8249); + opt_nowait_or_skip(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_locking_strengthContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public TerminalNode SHARE() { return getToken(PostgreSqlParser.SHARE, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode KEY() { return getToken(PostgreSqlParser.KEY, 0); } + public For_locking_strengthContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for_locking_strength; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFor_locking_strength(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFor_locking_strength(this); + } + } + + public final For_locking_strengthContext for_locking_strength() throws RecognitionException { + For_locking_strengthContext _localctx = new For_locking_strengthContext(_ctx, getState()); + enterRule(_localctx, 1050, RULE_for_locking_strength); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8251); + match(FOR); + setState(8261); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NO: + case UPDATE: + { + setState(8254); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(8252); + match(NO); + setState(8253); + match(KEY); + } + } + + setState(8256); + match(UPDATE); + } + break; + case KEY: + case SHARE: + { + setState(8258); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==KEY) { + { + setState(8257); + match(KEY); + } + } + + setState(8260); + match(SHARE); + } + break; + default: + throw new NoViableAltException(this); } } } @@ -35138,1308 +65895,797 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Column_listContext extends ParserRuleContext { - public ExprContext column_name_; - public Name_Context output_name; - public List STAR() { return getTokens(PostgreSqlParser.STAR); } - public TerminalNode STAR(int i) { - return getToken(PostgreSqlParser.STAR, i); + public static class Locked_rels_listContext extends ParserRuleContext { + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public Qualified_name_listContext qualified_name_list() { + return getRuleContext(Qualified_name_listContext.class,0); + } + public Locked_rels_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_locked_rels_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLocked_rels_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLocked_rels_list(this); + } + } + + public final Locked_rels_listContext locked_rels_list() throws RecognitionException { + Locked_rels_listContext _localctx = new Locked_rels_listContext(_ctx, getState()); + enterRule(_localctx, 1052, RULE_locked_rels_list); + try { + setState(8266); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OF: + enterOuterAlt(_localctx, 1); + { + setState(8263); + match(OF); + setState(8264); + qualified_name_list(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case FOR: + case GRANT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case RETURNING: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case NOWAIT: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case SKIP_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Values_clauseContext extends ParserRuleContext { + public TerminalNode VALUES() { return getToken(PostgreSqlParser.VALUES, 0); } + public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } + public TerminalNode OPEN_PAREN(int i) { + return getToken(PostgreSqlParser.OPEN_PAREN, i); + } + public List expr_list() { + return getRuleContexts(Expr_listContext.class); + } + public Expr_listContext expr_list(int i) { + return getRuleContext(Expr_listContext.class,i); + } + public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } + public TerminalNode CLOSE_PAREN(int i) { + return getToken(PostgreSqlParser.CLOSE_PAREN, i); } public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(PostgreSqlParser.COMMA, i); } - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public List name_() { - return getRuleContexts(Name_Context.class); - } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); - } - public List AS() { return getTokens(PostgreSqlParser.AS); } - public TerminalNode AS(int i) { - return getToken(PostgreSqlParser.AS, i); - } - public Column_listContext(ParserRuleContext parent, int invokingState) { + public Values_clauseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_column_list; } + @Override public int getRuleIndex() { return RULE_values_clause; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterValues_clause(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitValues_clause(this); } } - public final Column_listContext column_list() throws RecognitionException { - Column_listContext _localctx = new Column_listContext(_ctx, getState()); - enterRule(_localctx, 396, RULE_column_list); + public final Values_clauseContext values_clause() throws RecognitionException { + Values_clauseContext _localctx = new Values_clauseContext(_ctx, getState()); + enterRule(_localctx, 1054, RULE_values_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8268); + match(VALUES); + setState(8269); + match(OPEN_PAREN); + setState(8270); + expr_list(); + setState(8271); + match(CLOSE_PAREN); + setState(8279); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(8272); + match(COMMA); + setState(8273); + match(OPEN_PAREN); + setState(8274); + expr_list(); + setState(8275); + match(CLOSE_PAREN); + } + } + setState(8281); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class From_clauseContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public From_listContext from_list() { + return getRuleContext(From_listContext.class,0); + } + public From_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_from_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrom_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrom_clause(this); + } + } + + public final From_clauseContext from_clause() throws RecognitionException { + From_clauseContext _localctx = new From_clauseContext(_ctx, getState()); + enterRule(_localctx, 1056, RULE_from_clause); + try { + setState(8285); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FROM: + enterOuterAlt(_localctx, 1); + { + setState(8282); + match(FROM); + setState(8283); + from_list(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case EXCEPT: + case FETCH: + case FOR: + case GRANT: + case GROUP_P: + case HAVING: + case INTERSECT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case ORDER: + case RETURNING: + case SELECT: + case TABLE: + case THEN: + case UNION: + case USING: + case WHEN: + case WHERE: + case WINDOW: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class From_listContext extends ParserRuleContext { + public Non_ansi_joinContext non_ansi_join() { + return getRuleContext(Non_ansi_joinContext.class,0); + } + public List table_ref() { + return getRuleContexts(Table_refContext.class); + } + public Table_refContext table_ref(int i) { + return getRuleContext(Table_refContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public From_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_from_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrom_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrom_list(this); + } + } + + public final From_listContext from_list() throws RecognitionException { + From_listContext _localctx = new From_listContext(_ctx, getState()); + enterRule(_localctx, 1058, RULE_from_list); + try { + int _alt; + setState(8296); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,468,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8287); + non_ansi_join(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8288); + table_ref(); + setState(8293); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,467,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8289); + match(COMMA); + setState(8290); + table_ref(); + } + } + } + setState(8295); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,467,_ctx); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Non_ansi_joinContext extends ParserRuleContext { + public List table_ref() { + return getRuleContexts(Table_refContext.class); + } + public Table_refContext table_ref(int i) { + return getRuleContext(Table_refContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Non_ansi_joinContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_non_ansi_join; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNon_ansi_join(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNon_ansi_join(this); + } + } + + public final Non_ansi_joinContext non_ansi_join() throws RecognitionException { + Non_ansi_joinContext _localctx = new Non_ansi_joinContext(_ctx, getState()); + enterRule(_localctx, 1060, RULE_non_ansi_join); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8298); + table_ref(); + setState(8301); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(8299); + match(COMMA); + setState(8300); + table_ref(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(8303); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,469,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Table_refContext extends ParserRuleContext { + public Relation_exprContext relation_expr() { + return getRuleContext(Relation_exprContext.class,0); + } + public Opt_alias_clauseContext opt_alias_clause() { + return getRuleContext(Opt_alias_clauseContext.class,0); + } + public Func_tableContext func_table() { + return getRuleContext(Func_tableContext.class,0); + } + public Func_alias_clauseContext func_alias_clause() { + return getRuleContext(Func_alias_clauseContext.class,0); + } + public XmltableContext xmltable() { + return getRuleContext(XmltableContext.class,0); + } + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public TerminalNode LATERAL_P() { return getToken(PostgreSqlParser.LATERAL_P, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public List table_ref() { + return getRuleContexts(Table_refContext.class); + } + public Table_refContext table_ref(int i) { + return getRuleContext(Table_refContext.class,i); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public List CROSS() { return getTokens(PostgreSqlParser.CROSS); } + public TerminalNode CROSS(int i) { + return getToken(PostgreSqlParser.CROSS, i); + } + public List JOIN() { return getTokens(PostgreSqlParser.JOIN); } + public TerminalNode JOIN(int i) { + return getToken(PostgreSqlParser.JOIN, i); + } + public List NATURAL() { return getTokens(PostgreSqlParser.NATURAL); } + public TerminalNode NATURAL(int i) { + return getToken(PostgreSqlParser.NATURAL, i); + } + public List join_qual() { + return getRuleContexts(Join_qualContext.class); + } + public Join_qualContext join_qual(int i) { + return getRuleContext(Join_qualContext.class,i); + } + public Tablesample_clauseContext tablesample_clause() { + return getRuleContext(Tablesample_clauseContext.class,0); + } + public List join_type() { + return getRuleContexts(Join_typeContext.class); + } + public Join_typeContext join_type(int i) { + return getRuleContext(Join_typeContext.class,i); + } + public Table_refContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_table_ref; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTable_ref(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTable_ref(this); + } + } + + public final Table_refContext table_ref() throws RecognitionException { + Table_refContext _localctx = new Table_refContext(_ctx, getState()); + enterRule(_localctx, 1062, RULE_table_ref); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(4407); + setState(8354); _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALL: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ARRAY: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CASE: - case CAST: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DATE: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_ROLE: - case CURRENT_TIME: - case CURRENT_TIMESTAMP: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURRENT_USER: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULT: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FALSE: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOT: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULL: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITH: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case COLON: - case DOLLAR: - case DOLLAR_DOLLAR: - case OPEN_PAREN: - case BIT_STRING: - case REGEX_STRING: - case NUMERIC_LITERAL: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case DOLLAR_DEC: - case IDENTIFIER_UNICODE: - case AT_SIGN: - case BANG_BANG: - case MINUS: - case PLUS: - case QMARK: - case QMARK_HYPHEN: - case TIL: + switch ( getInterpreter().adaptivePredict(_input,475,_ctx) ) { + case 1: { - { - setState(4399); - ((Column_listContext)_localctx).column_name_ = expr(0); - setState(4404); + setState(8305); + relation_expr(); + setState(8306); + opt_alias_clause(); + setState(8308); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,511,_ctx) ) { + _la = _input.LA(1); + if (_la==TABLESAMPLE) { + { + setState(8307); + tablesample_clause(); + } + } + + } + break; + case 2: + { + setState(8310); + func_table(); + setState(8311); + func_alias_clause(); + } + break; + case 3: + { + setState(8313); + xmltable(); + setState(8314); + opt_alias_clause(); + } + break; + case 4: + { + setState(8316); + select_with_parens(); + setState(8317); + opt_alias_clause(); + } + break; + case 5: + { + setState(8319); + match(LATERAL_P); + setState(8329); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,471,_ctx) ) { case 1: { - setState(4401); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(4400); - match(AS); - } + setState(8320); + xmltable(); + setState(8321); + opt_alias_clause(); } - - setState(4403); - ((Column_listContext)_localctx).output_name = name_(); + break; + case 2: + { + setState(8323); + func_table(); + setState(8324); + func_alias_clause(); + } + break; + case 3: + { + setState(8326); + select_with_parens(); + setState(8327); + opt_alias_clause(); } break; } } - } break; - case STAR: + case 6: { - setState(4406); - match(STAR); + setState(8331); + match(OPEN_PAREN); + setState(8332); + table_ref(); + setState(8349); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CROSS: + { + setState(8333); + match(CROSS); + setState(8334); + match(JOIN); + setState(8335); + table_ref(); + } + break; + case NATURAL: + { + setState(8336); + match(NATURAL); + setState(8338); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & 8261L) != 0)) { + { + setState(8337); + join_type(); + } + } + + setState(8340); + match(JOIN); + setState(8341); + table_ref(); + } + break; + case FULL: + case INNER_P: + case JOIN: + case LEFT: + case RIGHT: + { + setState(8343); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & 8261L) != 0)) { + { + setState(8342); + join_type(); + } + } + + setState(8345); + match(JOIN); + setState(8346); + table_ref(); + setState(8347); + join_qual(); + } + break; + case CLOSE_PAREN: + break; + default: + break; + } + setState(8351); + match(CLOSE_PAREN); + setState(8352); + opt_alias_clause(); } break; - default: - throw new NoViableAltException(this); } - setState(4422); + setState(8374); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,516,_ctx); + _alt = getInterpreter().adaptivePredict(_input,479,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - { - setState(4409); - match(COMMA); - setState(4418); + setState(8372); _errHandler.sync(this); switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALL: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ARRAY: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CASE: - case CAST: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DATE: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_ROLE: - case CURRENT_TIME: - case CURRENT_TIMESTAMP: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURRENT_USER: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULT: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FALSE: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOT: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULL: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITH: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case COLON: - case DOLLAR: - case DOLLAR_DOLLAR: - case OPEN_PAREN: - case BIT_STRING: - case REGEX_STRING: - case NUMERIC_LITERAL: - case INTEGER_LITERAL: - case HEX_INTEGER_LITERAL: - case SINGLEQ_STRING_LITERAL: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case DOLLAR_DEC: - case IDENTIFIER_UNICODE: - case AT_SIGN: - case BANG_BANG: - case MINUS: - case PLUS: - case QMARK: - case QMARK_HYPHEN: - case TIL: + case CROSS: { - { - setState(4410); - ((Column_listContext)_localctx).column_name_ = expr(0); - setState(4415); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,514,_ctx) ) { - case 1: - { - setState(4412); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(4411); - match(AS); - } - } - - setState(4414); - ((Column_listContext)_localctx).output_name = name_(); - } - break; - } - } + setState(8356); + match(CROSS); + setState(8357); + match(JOIN); + setState(8358); + table_ref(); } break; - case STAR: + case NATURAL: { - setState(4417); - match(STAR); + setState(8359); + match(NATURAL); + setState(8361); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & 8261L) != 0)) { + { + setState(8360); + join_type(); + } + } + + setState(8363); + match(JOIN); + setState(8364); + table_ref(); + } + break; + case FULL: + case INNER_P: + case JOIN: + case LEFT: + case RIGHT: + { + setState(8366); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & 8261L) != 0)) { + { + setState(8365); + join_type(); + } + } + + setState(8368); + match(JOIN); + setState(8369); + table_ref(); + setState(8370); + join_qual(); } break; default: throw new NoViableAltException(this); } - } } } - setState(4424); + setState(8376); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,516,_ctx); + _alt = getInterpreter().adaptivePredict(_input,479,_ctx); } } } @@ -36455,85 +66701,2054 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Explain_parameterContext extends ParserRuleContext { - public TerminalNode ANALYZE() { return getToken(PostgreSqlParser.ANALYZE, 0); } - public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } - public TerminalNode COSTS() { return getToken(PostgreSqlParser.COSTS, 0); } - public TerminalNode BUFFERS() { return getToken(PostgreSqlParser.BUFFERS, 0); } - public TerminalNode TIMING() { return getToken(PostgreSqlParser.TIMING, 0); } - public Param_valueContext param_value() { - return getRuleContext(Param_valueContext.class,0); + public static class Alias_clauseContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); } - public TerminalNode FORMAT() { return getToken(PostgreSqlParser.FORMAT, 0); } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public TerminalNode XML() { return getToken(PostgreSqlParser.XML, 0); } - public TerminalNode JSON() { return getToken(PostgreSqlParser.JSON, 0); } - public TerminalNode YAML() { return getToken(PostgreSqlParser.YAML, 0); } - public Explain_parameterContext(ParserRuleContext parent, int invokingState) { + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Name_listContext name_list() { + return getRuleContext(Name_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Alias_clauseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_explain_parameter; } + @Override public int getRuleIndex() { return RULE_alias_clause; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplain_parameter(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlias_clause(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplain_parameter(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlias_clause(this); } } - public final Explain_parameterContext explain_parameter() throws RecognitionException { - Explain_parameterContext _localctx = new Explain_parameterContext(_ctx, getState()); - enterRule(_localctx, 398, RULE_explain_parameter); + public final Alias_clauseContext alias_clause() throws RecognitionException { + Alias_clauseContext _localctx = new Alias_clauseContext(_ctx, getState()); + enterRule(_localctx, 1064, RULE_alias_clause); int _la; try { - setState(4431); + enterOuterAlt(_localctx, 1); + { + setState(8378); _errHandler.sync(this); - switch (_input.LA(1)) { - case ANALYZE: - case BUFFERS: - case COSTS: - case TIMING: - case VERBOSE: + _la = _input.LA(1); + if (_la==AS) { + { + setState(8377); + match(AS); + } + } + + setState(8380); + colid(); + setState(8385); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,481,_ctx) ) { + case 1: + { + setState(8381); + match(OPEN_PAREN); + setState(8382); + name_list(); + setState(8383); + match(CLOSE_PAREN); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_alias_clauseContext extends ParserRuleContext { + public Table_alias_clauseContext table_alias_clause() { + return getRuleContext(Table_alias_clauseContext.class,0); + } + public Opt_alias_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_alias_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_alias_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_alias_clause(this); + } + } + + public final Opt_alias_clauseContext opt_alias_clause() throws RecognitionException { + Opt_alias_clauseContext _localctx = new Opt_alias_clauseContext(_ctx, getState()); + enterRule(_localctx, 1066, RULE_opt_alias_clause); + try { + setState(8389); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,482,_ctx) ) { + case 1: enterOuterAlt(_localctx, 1); { - setState(4425); - _la = _input.LA(1); - if ( !(_la==ANALYZE || _la==BUFFERS || _la==COSTS || _la==TIMING || _la==VERBOSE) ) { - _errHandler.recoverInline(this); + setState(8387); + table_alias_clause(); } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); + break; + case 2: + enterOuterAlt(_localctx, 2); + { } - setState(4427); + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Table_alias_clauseContext extends ParserRuleContext { + public Table_aliasContext table_alias() { + return getRuleContext(Table_aliasContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Name_listContext name_list() { + return getRuleContext(Name_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Table_alias_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_table_alias_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTable_alias_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTable_alias_clause(this); + } + } + + public final Table_alias_clauseContext table_alias_clause() throws RecognitionException { + Table_alias_clauseContext _localctx = new Table_alias_clauseContext(_ctx, getState()); + enterRule(_localctx, 1068, RULE_table_alias_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8392); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(8391); + match(AS); + } + } + + setState(8394); + table_alias(); + setState(8399); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,484,_ctx) ) { + case 1: + { + setState(8395); + match(OPEN_PAREN); + setState(8396); + name_list(); + setState(8397); + match(CLOSE_PAREN); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_alias_clauseContext extends ParserRuleContext { + public Alias_clauseContext alias_clause() { + return getRuleContext(Alias_clauseContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TablefuncelementlistContext tablefuncelementlist() { + return getRuleContext(TablefuncelementlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Func_alias_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_alias_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_alias_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_alias_clause(this); + } + } + + public final Func_alias_clauseContext func_alias_clause() throws RecognitionException { + Func_alias_clauseContext _localctx = new Func_alias_clauseContext(_ctx, getState()); + enterRule(_localctx, 1070, RULE_func_alias_clause); + int _la; + try { + setState(8414); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,487,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8401); + alias_clause(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8407); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AS: + { + setState(8402); + match(AS); + setState(8404); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8610636025129074688L) != 0) || ((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & -113665638399L) != 0) || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & -1L) != 0) || ((((_la - 222)) & ~0x3f) == 0 && ((1L << (_la - 222)) & -9663676417L) != 0) || ((((_la - 286)) & ~0x3f) == 0 && ((1L << (_la - 286)) & -1L) != 0) || ((((_la - 350)) & ~0x3f) == 0 && ((1L << (_la - 350)) & -1L) != 0) || ((((_la - 414)) & ~0x3f) == 0 && ((1L << (_la - 414)) & -1152925902653358081L) != 0) || ((((_la - 478)) & ~0x3f) == 0 && ((1L << (_la - 478)) & -43981136199681L) != 0) || ((((_la - 542)) & ~0x3f) == 0 && ((1L << (_la - 542)) & -1L) != 0) || ((((_la - 606)) & ~0x3f) == 0 && ((1L << (_la - 606)) & 288230685389357055L) != 0)) { + { + setState(8403); + colid(); + } + } + + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(8406); + colid(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(8409); + match(OPEN_PAREN); + setState(8410); + tablefuncelementlist(); + setState(8411); + match(CLOSE_PAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Join_typeContext extends ParserRuleContext { + public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } + public TerminalNode LEFT() { return getToken(PostgreSqlParser.LEFT, 0); } + public TerminalNode RIGHT() { return getToken(PostgreSqlParser.RIGHT, 0); } + public TerminalNode INNER_P() { return getToken(PostgreSqlParser.INNER_P, 0); } + public TerminalNode OUTER_P() { return getToken(PostgreSqlParser.OUTER_P, 0); } + public Join_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_join_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterJoin_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitJoin_type(this); + } + } + + public final Join_typeContext join_type() throws RecognitionException { + Join_typeContext _localctx = new Join_typeContext(_ctx, getState()); + enterRule(_localctx, 1072, RULE_join_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8416); + _la = _input.LA(1); + if ( !(((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & 8261L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8418); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OUTER_P) { + { + setState(8417); + match(OUTER_P); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Join_qualContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Name_listContext name_list() { + return getRuleContext(Name_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Join_qualContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_join_qual; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterJoin_qual(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitJoin_qual(this); + } + } + + public final Join_qualContext join_qual() throws RecognitionException { + Join_qualContext _localctx = new Join_qualContext(_ctx, getState()); + enterRule(_localctx, 1074, RULE_join_qual); + try { + setState(8427); + _errHandler.sync(this); + switch (_input.LA(1)) { + case USING: + enterOuterAlt(_localctx, 1); + { + setState(8420); + match(USING); + setState(8421); + match(OPEN_PAREN); + setState(8422); + name_list(); + setState(8423); + match(CLOSE_PAREN); + } + break; + case ON: + enterOuterAlt(_localctx, 2); + { + setState(8425); + match(ON); + setState(8426); + a_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Relation_exprContext extends ParserRuleContext { + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Relation_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_relation_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRelation_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRelation_expr(this); + } + } + + public final Relation_exprContext relation_expr() throws RecognitionException { + Relation_exprContext _localctx = new Relation_exprContext(_ctx, getState()); + enterRule(_localctx, 1076, RULE_relation_expr); + int _la; + try { + setState(8441); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(8429); + qualified_name(); + setState(8431); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245452583049L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -2918355150198407171L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3120954820635131899L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710895L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3341677518431191039L) != 0) || _la==QMARK) { + if (_la==STAR) { { - setState(4426); - param_value(); + setState(8430); + match(STAR); } } } break; - case FORMAT: + case ONLY: enterOuterAlt(_localctx, 2); { - setState(4429); - match(FORMAT); - setState(4430); - _la = _input.LA(1); - if ( !(_la==YAML || ((((_la - 736)) & ~0x3f) == 0 && ((1L << (_la - 736)) & 33685505L) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); + setState(8433); + match(ONLY); + setState(8439); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(8434); + qualified_name(); + } + break; + case OPEN_PAREN: + { + setState(8435); + match(OPEN_PAREN); + setState(8436); + qualified_name(); + setState(8437); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); } } break; @@ -36553,79 +68768,2493 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class FrameContext extends ParserRuleContext { - public TerminalNode UNBOUNDED() { return getToken(PostgreSqlParser.UNBOUNDED, 0); } - public TerminalNode PRECEDING() { return getToken(PostgreSqlParser.PRECEDING, 0); } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral() { - return getRuleContext(ParameterOrIntegerLiteralContext.class,0); + public static class Relation_expr_listContext extends ParserRuleContext { + public List relation_expr() { + return getRuleContexts(Relation_exprContext.class); } - public TerminalNode CURRENT() { return getToken(PostgreSqlParser.CURRENT, 0); } - public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } - public TerminalNode FOLLOWING() { return getToken(PostgreSqlParser.FOLLOWING, 0); } - public FrameContext(ParserRuleContext parent, int invokingState) { + public Relation_exprContext relation_expr(int i) { + return getRuleContext(Relation_exprContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Relation_expr_listContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_frame; } + @Override public int getRuleIndex() { return RULE_relation_expr_list; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrame(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRelation_expr_list(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrame(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRelation_expr_list(this); } } - public final FrameContext frame() throws RecognitionException { - FrameContext _localctx = new FrameContext(_ctx, getState()); - enterRule(_localctx, 400, RULE_frame); + public final Relation_expr_listContext relation_expr_list() throws RecognitionException { + Relation_expr_listContext _localctx = new Relation_expr_listContext(_ctx, getState()); + enterRule(_localctx, 1078, RULE_relation_expr_list); + int _la; try { - setState(4445); + enterOuterAlt(_localctx, 1); + { + setState(8443); + relation_expr(); + setState(8448); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,519,_ctx) ) { + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(8444); + match(COMMA); + setState(8445); + relation_expr(); + } + } + setState(8450); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Relation_expr_opt_aliasContext extends ParserRuleContext { + public Relation_exprContext relation_expr() { + return getRuleContext(Relation_exprContext.class,0); + } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public Relation_expr_opt_aliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_relation_expr_opt_alias; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRelation_expr_opt_alias(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRelation_expr_opt_alias(this); + } + } + + public final Relation_expr_opt_aliasContext relation_expr_opt_alias() throws RecognitionException { + Relation_expr_opt_aliasContext _localctx = new Relation_expr_opt_aliasContext(_ctx, getState()); + enterRule(_localctx, 1080, RULE_relation_expr_opt_alias); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8451); + relation_expr(); + setState(8456); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,495,_ctx) ) { + case 1: + { + setState(8453); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(8452); + match(AS); + } + } + + setState(8455); + colid(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Tablesample_clauseContext extends ParserRuleContext { + public TerminalNode TABLESAMPLE() { return getToken(PostgreSqlParser.TABLESAMPLE, 0); } + public Func_nameContext func_name() { + return getRuleContext(Func_nameContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_repeatable_clauseContext opt_repeatable_clause() { + return getRuleContext(Opt_repeatable_clauseContext.class,0); + } + public Tablesample_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tablesample_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTablesample_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTablesample_clause(this); + } + } + + public final Tablesample_clauseContext tablesample_clause() throws RecognitionException { + Tablesample_clauseContext _localctx = new Tablesample_clauseContext(_ctx, getState()); + enterRule(_localctx, 1082, RULE_tablesample_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(8458); + match(TABLESAMPLE); + setState(8459); + func_name(); + setState(8460); + match(OPEN_PAREN); + setState(8461); + expr_list(); + setState(8462); + match(CLOSE_PAREN); + setState(8463); + opt_repeatable_clause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_repeatable_clauseContext extends ParserRuleContext { + public TerminalNode REPEATABLE() { return getToken(PostgreSqlParser.REPEATABLE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_repeatable_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_repeatable_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_repeatable_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_repeatable_clause(this); + } + } + + public final Opt_repeatable_clauseContext opt_repeatable_clause() throws RecognitionException { + Opt_repeatable_clauseContext _localctx = new Opt_repeatable_clauseContext(_ctx, getState()); + enterRule(_localctx, 1084, RULE_opt_repeatable_clause); + try { + setState(8471); + _errHandler.sync(this); + switch (_input.LA(1)) { + case REPEATABLE: + enterOuterAlt(_localctx, 1); + { + setState(8465); + match(REPEATABLE); + setState(8466); + match(OPEN_PAREN); + setState(8467); + a_expr(); + setState(8468); + match(CLOSE_PAREN); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case EXCEPT: + case FETCH: + case FOR: + case GRANT: + case GROUP_P: + case HAVING: + case INTERSECT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case ORDER: + case RETURNING: + case SELECT: + case TABLE: + case THEN: + case UNION: + case USING: + case WHEN: + case WHERE: + case WINDOW: + case WITH: + case CROSS: + case FULL: + case INNER_P: + case JOIN: + case LEFT: + case NATURAL: + case RIGHT: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_tableContext extends ParserRuleContext { + public Func_expr_windowlessContext func_expr_windowless() { + return getRuleContext(Func_expr_windowlessContext.class,0); + } + public Opt_ordinalityContext opt_ordinality() { + return getRuleContext(Opt_ordinalityContext.class,0); + } + public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Rowsfrom_listContext rowsfrom_list() { + return getRuleContext(Rowsfrom_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Func_tableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_table; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_table(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_table(this); + } + } + + public final Func_tableContext func_table() throws RecognitionException { + Func_tableContext _localctx = new Func_tableContext(_ctx, getState()); + enterRule(_localctx, 1086, RULE_func_table); + try { + setState(8483); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,497,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(4433); - match(UNBOUNDED); - setState(4434); - match(PRECEDING); + setState(8473); + func_expr_windowless(); + setState(8474); + opt_ordinality(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(4435); - parameterOrIntegerLiteral(); - setState(4436); - match(PRECEDING); + setState(8476); + match(ROWS); + setState(8477); + match(FROM); + setState(8478); + match(OPEN_PAREN); + setState(8479); + rowsfrom_list(); + setState(8480); + match(CLOSE_PAREN); + setState(8481); + opt_ordinality(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Rowsfrom_itemContext extends ParserRuleContext { + public Func_expr_windowlessContext func_expr_windowless() { + return getRuleContext(Func_expr_windowlessContext.class,0); + } + public Opt_col_def_listContext opt_col_def_list() { + return getRuleContext(Opt_col_def_listContext.class,0); + } + public Rowsfrom_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rowsfrom_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRowsfrom_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRowsfrom_item(this); + } + } + + public final Rowsfrom_itemContext rowsfrom_item() throws RecognitionException { + Rowsfrom_itemContext _localctx = new Rowsfrom_itemContext(_ctx, getState()); + enterRule(_localctx, 1088, RULE_rowsfrom_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(8485); + func_expr_windowless(); + setState(8486); + opt_col_def_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Rowsfrom_listContext extends ParserRuleContext { + public List rowsfrom_item() { + return getRuleContexts(Rowsfrom_itemContext.class); + } + public Rowsfrom_itemContext rowsfrom_item(int i) { + return getRuleContext(Rowsfrom_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Rowsfrom_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rowsfrom_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRowsfrom_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRowsfrom_list(this); + } + } + + public final Rowsfrom_listContext rowsfrom_list() throws RecognitionException { + Rowsfrom_listContext _localctx = new Rowsfrom_listContext(_ctx, getState()); + enterRule(_localctx, 1090, RULE_rowsfrom_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8488); + rowsfrom_item(); + setState(8493); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(8489); + match(COMMA); + setState(8490); + rowsfrom_item(); + } + } + setState(8495); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_col_def_listContext extends ParserRuleContext { + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TablefuncelementlistContext tablefuncelementlist() { + return getRuleContext(TablefuncelementlistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_col_def_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_col_def_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_col_def_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_col_def_list(this); + } + } + + public final Opt_col_def_listContext opt_col_def_list() throws RecognitionException { + Opt_col_def_listContext _localctx = new Opt_col_def_listContext(_ctx, getState()); + enterRule(_localctx, 1092, RULE_opt_col_def_list); + try { + setState(8502); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AS: + enterOuterAlt(_localctx, 1); + { + setState(8496); + match(AS); + setState(8497); + match(OPEN_PAREN); + setState(8498); + tablefuncelementlist(); + setState(8499); + match(CLOSE_PAREN); + } + break; + case CLOSE_PAREN: + case COMMA: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_ordinalityContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode ORDINALITY() { return getToken(PostgreSqlParser.ORDINALITY, 0); } + public Opt_ordinalityContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_ordinality; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_ordinality(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_ordinality(this); + } + } + + public final Opt_ordinalityContext opt_ordinality() throws RecognitionException { + Opt_ordinalityContext _localctx = new Opt_ordinalityContext(_ctx, getState()); + enterRule(_localctx, 1094, RULE_opt_ordinality); + try { + setState(8507); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,500,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8504); + match(WITH); + setState(8505); + match(ORDINALITY); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Where_clauseContext extends ParserRuleContext { + public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Where_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_where_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWhere_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWhere_clause(this); + } + } + + public final Where_clauseContext where_clause() throws RecognitionException { + Where_clauseContext _localctx = new Where_clauseContext(_ctx, getState()); + enterRule(_localctx, 1096, RULE_where_clause); + try { + setState(8512); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WHERE: + enterOuterAlt(_localctx, 1); + { + setState(8509); + match(WHERE); + setState(8510); + a_expr(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case EXCEPT: + case FETCH: + case FOR: + case GRANT: + case GROUP_P: + case HAVING: + case INTERSECT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case ORDER: + case RETURNING: + case SELECT: + case TABLE: + case THEN: + case UNION: + case USING: + case WHEN: + case WINDOW: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Where_or_current_clauseContext extends ParserRuleContext { + public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } + public TerminalNode CURRENT_P() { return getToken(PostgreSqlParser.CURRENT_P, 0); } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public Cursor_nameContext cursor_name() { + return getRuleContext(Cursor_nameContext.class,0); + } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Where_or_current_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_where_or_current_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWhere_or_current_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWhere_or_current_clause(this); + } + } + + public final Where_or_current_clauseContext where_or_current_clause() throws RecognitionException { + Where_or_current_clauseContext _localctx = new Where_or_current_clauseContext(_ctx, getState()); + enterRule(_localctx, 1098, RULE_where_or_current_clause); + try { + setState(8522); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WHERE: + enterOuterAlt(_localctx, 1); + { + setState(8514); + match(WHERE); + setState(8519); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,502,_ctx) ) { + case 1: + { + setState(8515); + match(CURRENT_P); + setState(8516); + match(OF); + setState(8517); + cursor_name(); + } + break; + case 2: + { + setState(8518); + a_expr(); + } + break; + } + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case FETCH: + case GRANT: + case INTO: + case RETURNING: + case SELECT: + case TABLE: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OpttablefuncelementlistContext extends ParserRuleContext { + public TablefuncelementlistContext tablefuncelementlist() { + return getRuleContext(TablefuncelementlistContext.class,0); + } + public OpttablefuncelementlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opttablefuncelementlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpttablefuncelementlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpttablefuncelementlist(this); + } + } + + public final OpttablefuncelementlistContext opttablefuncelementlist() throws RecognitionException { + OpttablefuncelementlistContext _localctx = new OpttablefuncelementlistContext(_ctx, getState()); + enterRule(_localctx, 1100, RULE_opttablefuncelementlist); + try { + setState(8526); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(8524); + tablefuncelementlist(); + } + break; + case CLOSE_PAREN: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TablefuncelementlistContext extends ParserRuleContext { + public List tablefuncelement() { + return getRuleContexts(TablefuncelementContext.class); + } + public TablefuncelementContext tablefuncelement(int i) { + return getRuleContext(TablefuncelementContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public TablefuncelementlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tablefuncelementlist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTablefuncelementlist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTablefuncelementlist(this); + } + } + + public final TablefuncelementlistContext tablefuncelementlist() throws RecognitionException { + TablefuncelementlistContext _localctx = new TablefuncelementlistContext(_ctx, getState()); + enterRule(_localctx, 1102, RULE_tablefuncelementlist); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8528); + tablefuncelement(); + setState(8533); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(8529); + match(COMMA); + setState(8530); + tablefuncelement(); + } + } + setState(8535); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TablefuncelementContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public Opt_collate_clauseContext opt_collate_clause() { + return getRuleContext(Opt_collate_clauseContext.class,0); + } + public TablefuncelementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tablefuncelement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTablefuncelement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTablefuncelement(this); + } + } + + public final TablefuncelementContext tablefuncelement() throws RecognitionException { + TablefuncelementContext _localctx = new TablefuncelementContext(_ctx, getState()); + enterRule(_localctx, 1104, RULE_tablefuncelement); + try { + enterOuterAlt(_localctx, 1); + { + setState(8536); + colid(); + setState(8537); + typename(); + setState(8538); + opt_collate_clause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XmltableContext extends ParserRuleContext { + public TerminalNode XMLTABLE() { return getToken(PostgreSqlParser.XMLTABLE, 0); } + public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } + public TerminalNode OPEN_PAREN(int i) { + return getToken(PostgreSqlParser.OPEN_PAREN, i); + } + public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } + public TerminalNode CLOSE_PAREN(int i) { + return getToken(PostgreSqlParser.CLOSE_PAREN, i); + } + public C_exprContext c_expr() { + return getRuleContext(C_exprContext.class,0); + } + public Xmlexists_argumentContext xmlexists_argument() { + return getRuleContext(Xmlexists_argumentContext.class,0); + } + public TerminalNode COLUMNS() { return getToken(PostgreSqlParser.COLUMNS, 0); } + public Xmltable_column_listContext xmltable_column_list() { + return getRuleContext(Xmltable_column_listContext.class,0); + } + public TerminalNode XMLNAMESPACES() { return getToken(PostgreSqlParser.XMLNAMESPACES, 0); } + public Xml_namespace_listContext xml_namespace_list() { + return getRuleContext(Xml_namespace_listContext.class,0); + } + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public XmltableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xmltable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXmltable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXmltable(this); + } + } + + public final XmltableContext xmltable() throws RecognitionException { + XmltableContext _localctx = new XmltableContext(_ctx, getState()); + enterRule(_localctx, 1106, RULE_xmltable); + try { + enterOuterAlt(_localctx, 1); + { + setState(8540); + match(XMLTABLE); + setState(8541); + match(OPEN_PAREN); + setState(8557); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,506,_ctx) ) { + case 1: + { + setState(8542); + c_expr(); + setState(8543); + xmlexists_argument(); + setState(8544); + match(COLUMNS); + setState(8545); + xmltable_column_list(); + } + break; + case 2: + { + setState(8547); + match(XMLNAMESPACES); + setState(8548); + match(OPEN_PAREN); + setState(8549); + xml_namespace_list(); + setState(8550); + match(CLOSE_PAREN); + setState(8551); + match(COMMA); + setState(8552); + c_expr(); + setState(8553); + xmlexists_argument(); + setState(8554); + match(COLUMNS); + setState(8555); + xmltable_column_list(); + } + break; + } + setState(8559); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xmltable_column_listContext extends ParserRuleContext { + public List xmltable_column_el() { + return getRuleContexts(Xmltable_column_elContext.class); + } + public Xmltable_column_elContext xmltable_column_el(int i) { + return getRuleContext(Xmltable_column_elContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Xmltable_column_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xmltable_column_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXmltable_column_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXmltable_column_list(this); + } + } + + public final Xmltable_column_listContext xmltable_column_list() throws RecognitionException { + Xmltable_column_listContext _localctx = new Xmltable_column_listContext(_ctx, getState()); + enterRule(_localctx, 1108, RULE_xmltable_column_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8561); + xmltable_column_el(); + setState(8566); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(8562); + match(COMMA); + setState(8563); + xmltable_column_el(); + } + } + setState(8568); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xmltable_column_elContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode ORDINALITY() { return getToken(PostgreSqlParser.ORDINALITY, 0); } + public Xmltable_column_option_listContext xmltable_column_option_list() { + return getRuleContext(Xmltable_column_option_listContext.class,0); + } + public Xmltable_column_elContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xmltable_column_el; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXmltable_column_el(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXmltable_column_el(this); + } + } + + public final Xmltable_column_elContext xmltable_column_el() throws RecognitionException { + Xmltable_column_elContext _localctx = new Xmltable_column_elContext(_ctx, getState()); + enterRule(_localctx, 1110, RULE_xmltable_column_el); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8569); + colid(); + setState(8576); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(8570); + typename(); + setState(8572); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 35)) & ~0x3f) == 0 && ((1L << (_la - 35)) & 576513529147825157L) != 0) || ((((_la - 118)) & ~0x3f) == 0 && ((1L << (_la - 118)) & 74346914954363009L) != 0) || ((((_la - 209)) & ~0x3f) == 0 && ((1L << (_la - 209)) & 56295003965620233L) != 0) || ((((_la - 274)) & ~0x3f) == 0 && ((1L << (_la - 274)) & 18068292027564033L) != 0) || _la==TYPE_P || ((((_la - 435)) & ~0x3f) == 0 && ((1L << (_la - 435)) & -144097595889811453L) != 0) || ((((_la - 499)) & ~0x3f) == 0 && ((1L << (_la - 499)) & 12516927L) != 0) || ((((_la - 639)) & ~0x3f) == 0 && ((1L << (_la - 639)) & 33554467L) != 0)) { + { + setState(8571); + xmltable_column_option_list(); + } + } + + } + break; + case FOR: + { + setState(8574); + match(FOR); + setState(8575); + match(ORDINALITY); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xmltable_column_option_listContext extends ParserRuleContext { + public List xmltable_column_option_el() { + return getRuleContexts(Xmltable_column_option_elContext.class); + } + public Xmltable_column_option_elContext xmltable_column_option_el(int i) { + return getRuleContext(Xmltable_column_option_elContext.class,i); + } + public Xmltable_column_option_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xmltable_column_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXmltable_column_option_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXmltable_column_option_list(this); + } + } + + public final Xmltable_column_option_listContext xmltable_column_option_list() throws RecognitionException { + Xmltable_column_option_listContext _localctx = new Xmltable_column_option_listContext(_ctx, getState()); + enterRule(_localctx, 1112, RULE_xmltable_column_option_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8579); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(8578); + xmltable_column_option_el(); + } + } + setState(8581); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( ((((_la - 35)) & ~0x3f) == 0 && ((1L << (_la - 35)) & 576513529147825157L) != 0) || ((((_la - 118)) & ~0x3f) == 0 && ((1L << (_la - 118)) & 74346914954363009L) != 0) || ((((_la - 209)) & ~0x3f) == 0 && ((1L << (_la - 209)) & 56295003965620233L) != 0) || ((((_la - 274)) & ~0x3f) == 0 && ((1L << (_la - 274)) & 18068292027564033L) != 0) || _la==TYPE_P || ((((_la - 435)) & ~0x3f) == 0 && ((1L << (_la - 435)) & -144097595889811453L) != 0) || ((((_la - 499)) & ~0x3f) == 0 && ((1L << (_la - 499)) & 12516927L) != 0) || ((((_la - 639)) & ~0x3f) == 0 && ((1L << (_la - 639)) & 33554467L) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xmltable_column_option_elContext extends ParserRuleContext { + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public Xmltable_column_option_elContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xmltable_column_option_el; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXmltable_column_option_el(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXmltable_column_option_el(this); + } + } + + public final Xmltable_column_option_elContext xmltable_column_option_el() throws RecognitionException { + Xmltable_column_option_elContext _localctx = new Xmltable_column_option_elContext(_ctx, getState()); + enterRule(_localctx, 1114, RULE_xmltable_column_option_el); + try { + setState(8591); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,511,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8583); + match(DEFAULT); + setState(8584); + a_expr(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8585); + identifier(); + setState(8586); + a_expr(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(4438); - match(CURRENT); - setState(4439); - match(ROW); + setState(8588); + match(NOT); + setState(8589); + match(NULL_P); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(4440); - parameterOrIntegerLiteral(); - setState(4441); - match(FOLLOWING); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(4443); - match(UNBOUNDED); - setState(4444); - match(FOLLOWING); + setState(8590); + match(NULL_P); } break; } @@ -36642,142 +71271,233 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Frame_startContext extends ParserRuleContext { - public FrameContext frame() { - return getRuleContext(FrameContext.class,0); + public static class Xml_namespace_listContext extends ParserRuleContext { + public List xml_namespace_el() { + return getRuleContexts(Xml_namespace_elContext.class); } - public Frame_startContext(ParserRuleContext parent, int invokingState) { + public Xml_namespace_elContext xml_namespace_el(int i) { + return getRuleContext(Xml_namespace_elContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Xml_namespace_listContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_frame_start; } + @Override public int getRuleIndex() { return RULE_xml_namespace_list; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrame_start(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXml_namespace_list(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrame_start(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXml_namespace_list(this); } } - public final Frame_startContext frame_start() throws RecognitionException { - Frame_startContext _localctx = new Frame_startContext(_ctx, getState()); - enterRule(_localctx, 402, RULE_frame_start); - try { - enterOuterAlt(_localctx, 1); - { - setState(4447); - frame(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Frame_endContext extends ParserRuleContext { - public FrameContext frame() { - return getRuleContext(FrameContext.class,0); - } - public Frame_endContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_frame_end; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrame_end(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrame_end(this); - } - } - - public final Frame_endContext frame_end() throws RecognitionException { - Frame_endContext _localctx = new Frame_endContext(_ctx, getState()); - enterRule(_localctx, 404, RULE_frame_end); - try { - enterOuterAlt(_localctx, 1); - { - setState(4449); - frame(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Frame_clauseContext extends ParserRuleContext { - public Frame_startContext frame_start() { - return getRuleContext(Frame_startContext.class,0); - } - public TerminalNode RANGE() { return getToken(PostgreSqlParser.RANGE, 0); } - public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } - public TerminalNode BETWEEN() { return getToken(PostgreSqlParser.BETWEEN, 0); } - public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } - public Frame_endContext frame_end() { - return getRuleContext(Frame_endContext.class,0); - } - public Frame_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_frame_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrame_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrame_clause(this); - } - } - - public final Frame_clauseContext frame_clause() throws RecognitionException { - Frame_clauseContext _localctx = new Frame_clauseContext(_ctx, getState()); - enterRule(_localctx, 406, RULE_frame_clause); + public final Xml_namespace_listContext xml_namespace_list() throws RecognitionException { + Xml_namespace_listContext _localctx = new Xml_namespace_listContext(_ctx, getState()); + enterRule(_localctx, 1116, RULE_xml_namespace_list); int _la; try { - setState(4459); + enterOuterAlt(_localctx, 1); + { + setState(8593); + xml_namespace_el(); + setState(8598); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,520,_ctx) ) { + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(8594); + match(COMMA); + setState(8595); + xml_namespace_el(); + } + } + setState(8600); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xml_namespace_elContext extends ParserRuleContext { + public B_exprContext b_expr() { + return getRuleContext(B_exprContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public Xml_namespace_elContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xml_namespace_el; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXml_namespace_el(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXml_namespace_el(this); + } + } + + public final Xml_namespace_elContext xml_namespace_el() throws RecognitionException { + Xml_namespace_elContext _localctx = new Xml_namespace_elContext(_ctx, getState()); + enterRule(_localctx, 1118, RULE_xml_namespace_el); + try { + setState(8607); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,513,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(4451); - _la = _input.LA(1); - if ( !(_la==RANGE || _la==ROWS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4452); - frame_start(); + setState(8601); + b_expr(0); + setState(8602); + match(AS); + setState(8603); + collabel(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(4453); + setState(8605); + match(DEFAULT); + setState(8606); + b_expr(0); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypenameContext extends ParserRuleContext { + public SimpletypenameContext simpletypename() { + return getRuleContext(SimpletypenameContext.class,0); + } + public Opt_array_boundsContext opt_array_bounds() { + return getRuleContext(Opt_array_boundsContext.class,0); + } + public TerminalNode ARRAY() { return getToken(PostgreSqlParser.ARRAY, 0); } + public TerminalNode SETOF() { return getToken(PostgreSqlParser.SETOF, 0); } + public TerminalNode OPEN_BRACKET() { return getToken(PostgreSqlParser.OPEN_BRACKET, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CLOSE_BRACKET() { return getToken(PostgreSqlParser.CLOSE_BRACKET, 0); } + public Qualified_nameContext qualified_name() { + return getRuleContext(Qualified_nameContext.class,0); + } + public TerminalNode PERCENT() { return getToken(PostgreSqlParser.PERCENT, 0); } + public TerminalNode ROWTYPE() { return getToken(PostgreSqlParser.ROWTYPE, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TypenameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typename; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTypename(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTypename(this); + } + } + + public final TypenameContext typename() throws RecognitionException { + TypenameContext _localctx = new TypenameContext(_ctx, getState()); + enterRule(_localctx, 1120, RULE_typename); + int _la; + try { + setState(8627); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,517,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8610); + _errHandler.sync(this); _la = _input.LA(1); - if ( !(_la==RANGE || _la==ROWS) ) { + if (_la==SETOF) { + { + setState(8609); + match(SETOF); + } + } + + setState(8612); + simpletypename(); + setState(8621); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,516,_ctx) ) { + case 1: + { + setState(8613); + opt_array_bounds(); + } + break; + case 2: + { + setState(8614); + match(ARRAY); + setState(8619); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,515,_ctx) ) { + case 1: + { + setState(8615); + match(OPEN_BRACKET); + setState(8616); + iconst(); + setState(8617); + match(CLOSE_BRACKET); + } + break; + } + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8623); + qualified_name(); + setState(8624); + match(PERCENT); + setState(8625); + _la = _input.LA(1); + if ( !(_la==TYPE_P || _la==ROWTYPE) ) { _errHandler.recoverInline(this); } else { @@ -36785,14 +71505,6 @@ public class PostgreSqlParser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(4454); - match(BETWEEN); - setState(4455); - frame_start(); - setState(4456); - match(AND); - setState(4457); - frame_end(); } break; } @@ -36808,6 +71520,6498 @@ public class PostgreSqlParser extends Parser { return _localctx; } + @SuppressWarnings("CheckReturnValue") + public static class Opt_array_boundsContext extends ParserRuleContext { + public List OPEN_BRACKET() { return getTokens(PostgreSqlParser.OPEN_BRACKET); } + public TerminalNode OPEN_BRACKET(int i) { + return getToken(PostgreSqlParser.OPEN_BRACKET, i); + } + public List CLOSE_BRACKET() { return getTokens(PostgreSqlParser.CLOSE_BRACKET); } + public TerminalNode CLOSE_BRACKET(int i) { + return getToken(PostgreSqlParser.CLOSE_BRACKET, i); + } + public List iconst() { + return getRuleContexts(IconstContext.class); + } + public IconstContext iconst(int i) { + return getRuleContext(IconstContext.class,i); + } + public Opt_array_boundsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_array_bounds; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_array_bounds(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_array_bounds(this); + } + } + + public final Opt_array_boundsContext opt_array_bounds() throws RecognitionException { + Opt_array_boundsContext _localctx = new Opt_array_boundsContext(_ctx, getState()); + enterRule(_localctx, 1122, RULE_opt_array_bounds); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8636); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,519,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8629); + match(OPEN_BRACKET); + setState(8631); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Integral) { + { + setState(8630); + iconst(); + } + } + + setState(8633); + match(CLOSE_BRACKET); + } + } + } + setState(8638); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,519,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpletypenameContext extends ParserRuleContext { + public GenerictypeContext generictype() { + return getRuleContext(GenerictypeContext.class,0); + } + public NumericContext numeric() { + return getRuleContext(NumericContext.class,0); + } + public BitContext bit() { + return getRuleContext(BitContext.class,0); + } + public CharacterContext character() { + return getRuleContext(CharacterContext.class,0); + } + public ConstdatetimeContext constdatetime() { + return getRuleContext(ConstdatetimeContext.class,0); + } + public ConstintervalContext constinterval() { + return getRuleContext(ConstintervalContext.class,0); + } + public Opt_intervalContext opt_interval() { + return getRuleContext(Opt_intervalContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public SimpletypenameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpletypename; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSimpletypename(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSimpletypename(this); + } + } + + public final SimpletypenameContext simpletypename() throws RecognitionException { + SimpletypenameContext _localctx = new SimpletypenameContext(_ctx, getState()); + enterRule(_localctx, 1124, RULE_simpletypename); + try { + setState(8652); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,521,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8639); + generictype(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8640); + numeric(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(8641); + bit(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(8642); + character(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(8643); + constdatetime(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(8644); + constinterval(); + setState(8650); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,520,_ctx) ) { + case 1: + { + setState(8645); + opt_interval(); + } + break; + case 2: + { + setState(8646); + match(OPEN_PAREN); + setState(8647); + iconst(); + setState(8648); + match(CLOSE_PAREN); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConsttypenameContext extends ParserRuleContext { + public NumericContext numeric() { + return getRuleContext(NumericContext.class,0); + } + public ConstbitContext constbit() { + return getRuleContext(ConstbitContext.class,0); + } + public ConstcharacterContext constcharacter() { + return getRuleContext(ConstcharacterContext.class,0); + } + public ConstdatetimeContext constdatetime() { + return getRuleContext(ConstdatetimeContext.class,0); + } + public ConsttypenameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_consttypename; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConsttypename(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConsttypename(this); + } + } + + public final ConsttypenameContext consttypename() throws RecognitionException { + ConsttypenameContext _localctx = new ConsttypenameContext(_ctx, getState()); + enterRule(_localctx, 1126, RULE_consttypename); + try { + setState(8658); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOUBLE_P: + case BIGINT: + case BOOLEAN_P: + case DEC: + case DECIMAL_P: + case FLOAT_P: + case INT_P: + case INTEGER: + case NUMERIC: + case REAL: + case SMALLINT: + enterOuterAlt(_localctx, 1); + { + setState(8654); + numeric(); + } + break; + case BIT: + enterOuterAlt(_localctx, 2); + { + setState(8655); + constbit(); + } + break; + case CHAR_P: + case CHARACTER: + case NATIONAL: + case NCHAR: + case VARCHAR: + enterOuterAlt(_localctx, 3); + { + setState(8656); + constcharacter(); + } + break; + case TIME: + case TIMESTAMP: + enterOuterAlt(_localctx, 4); + { + setState(8657); + constdatetime(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GenerictypeContext extends ParserRuleContext { + public Opt_type_modifiersContext opt_type_modifiers() { + return getRuleContext(Opt_type_modifiersContext.class,0); + } + public Builtin_function_nameContext builtin_function_name() { + return getRuleContext(Builtin_function_nameContext.class,0); + } + public Type_function_nameContext type_function_name() { + return getRuleContext(Type_function_nameContext.class,0); + } + public TerminalNode LEFT() { return getToken(PostgreSqlParser.LEFT, 0); } + public TerminalNode RIGHT() { return getToken(PostgreSqlParser.RIGHT, 0); } + public AttrsContext attrs() { + return getRuleContext(AttrsContext.class,0); + } + public GenerictypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_generictype; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGenerictype(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGenerictype(this); + } + } + + public final GenerictypeContext generictype() throws RecognitionException { + GenerictypeContext _localctx = new GenerictypeContext(_ctx, getState()); + enterRule(_localctx, 1128, RULE_generictype); + try { + enterOuterAlt(_localctx, 1); + { + setState(8664); + _errHandler.sync(this); + switch (_input.LA(1)) { + case REPLACE: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case REVERSE: + case LOG: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + { + setState(8660); + builtin_function_name(); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case COLUMNS: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(8661); + type_function_name(); + } + break; + case LEFT: + { + setState(8662); + match(LEFT); + } + break; + case RIGHT: + { + setState(8663); + match(RIGHT); + } + break; + default: + throw new NoViableAltException(this); + } + setState(8667); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,524,_ctx) ) { + case 1: + { + setState(8666); + attrs(); + } + break; + } + setState(8669); + opt_type_modifiers(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_type_modifiersContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_type_modifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_type_modifiers; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_type_modifiers(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_type_modifiers(this); + } + } + + public final Opt_type_modifiersContext opt_type_modifiers() throws RecognitionException { + Opt_type_modifiersContext _localctx = new Opt_type_modifiersContext(_ctx, getState()); + enterRule(_localctx, 1130, RULE_opt_type_modifiers); + try { + setState(8676); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,525,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8671); + match(OPEN_PAREN); + setState(8672); + expr_list(); + setState(8673); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NumericContext extends ParserRuleContext { + public TerminalNode INT_P() { return getToken(PostgreSqlParser.INT_P, 0); } + public TerminalNode INTEGER() { return getToken(PostgreSqlParser.INTEGER, 0); } + public TerminalNode SMALLINT() { return getToken(PostgreSqlParser.SMALLINT, 0); } + public TerminalNode BIGINT() { return getToken(PostgreSqlParser.BIGINT, 0); } + public TerminalNode REAL() { return getToken(PostgreSqlParser.REAL, 0); } + public TerminalNode FLOAT_P() { return getToken(PostgreSqlParser.FLOAT_P, 0); } + public Opt_floatContext opt_float() { + return getRuleContext(Opt_floatContext.class,0); + } + public TerminalNode DOUBLE_P() { return getToken(PostgreSqlParser.DOUBLE_P, 0); } + public TerminalNode PRECISION() { return getToken(PostgreSqlParser.PRECISION, 0); } + public TerminalNode DECIMAL_P() { return getToken(PostgreSqlParser.DECIMAL_P, 0); } + public Opt_type_modifiersContext opt_type_modifiers() { + return getRuleContext(Opt_type_modifiersContext.class,0); + } + public TerminalNode DEC() { return getToken(PostgreSqlParser.DEC, 0); } + public TerminalNode NUMERIC() { return getToken(PostgreSqlParser.NUMERIC, 0); } + public TerminalNode BOOLEAN_P() { return getToken(PostgreSqlParser.BOOLEAN_P, 0); } + public NumericContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numeric; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNumeric(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNumeric(this); + } + } + + public final NumericContext numeric() throws RecognitionException { + NumericContext _localctx = new NumericContext(_ctx, getState()); + enterRule(_localctx, 1132, RULE_numeric); + try { + setState(8694); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INT_P: + enterOuterAlt(_localctx, 1); + { + setState(8678); + match(INT_P); + } + break; + case INTEGER: + enterOuterAlt(_localctx, 2); + { + setState(8679); + match(INTEGER); + } + break; + case SMALLINT: + enterOuterAlt(_localctx, 3); + { + setState(8680); + match(SMALLINT); + } + break; + case BIGINT: + enterOuterAlt(_localctx, 4); + { + setState(8681); + match(BIGINT); + } + break; + case REAL: + enterOuterAlt(_localctx, 5); + { + setState(8682); + match(REAL); + } + break; + case FLOAT_P: + enterOuterAlt(_localctx, 6); + { + setState(8683); + match(FLOAT_P); + setState(8684); + opt_float(); + } + break; + case DOUBLE_P: + enterOuterAlt(_localctx, 7); + { + setState(8685); + match(DOUBLE_P); + setState(8686); + match(PRECISION); + } + break; + case DECIMAL_P: + enterOuterAlt(_localctx, 8); + { + setState(8687); + match(DECIMAL_P); + setState(8688); + opt_type_modifiers(); + } + break; + case DEC: + enterOuterAlt(_localctx, 9); + { + setState(8689); + match(DEC); + setState(8690); + opt_type_modifiers(); + } + break; + case NUMERIC: + enterOuterAlt(_localctx, 10); + { + setState(8691); + match(NUMERIC); + setState(8692); + opt_type_modifiers(); + } + break; + case BOOLEAN_P: + enterOuterAlt(_localctx, 11); + { + setState(8693); + match(BOOLEAN_P); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_floatContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Opt_floatContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_float; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_float(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_float(this); + } + } + + public final Opt_floatContext opt_float() throws RecognitionException { + Opt_floatContext _localctx = new Opt_floatContext(_ctx, getState()); + enterRule(_localctx, 1134, RULE_opt_float); + try { + setState(8701); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,527,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8696); + match(OPEN_PAREN); + setState(8697); + iconst(); + setState(8698); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BitContext extends ParserRuleContext { + public BitwithlengthContext bitwithlength() { + return getRuleContext(BitwithlengthContext.class,0); + } + public BitwithoutlengthContext bitwithoutlength() { + return getRuleContext(BitwithoutlengthContext.class,0); + } + public BitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_bit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterBit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitBit(this); + } + } + + public final BitContext bit() throws RecognitionException { + BitContext _localctx = new BitContext(_ctx, getState()); + enterRule(_localctx, 1136, RULE_bit); + try { + setState(8705); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,528,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8703); + bitwithlength(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8704); + bitwithoutlength(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstbitContext extends ParserRuleContext { + public BitwithlengthContext bitwithlength() { + return getRuleContext(BitwithlengthContext.class,0); + } + public BitwithoutlengthContext bitwithoutlength() { + return getRuleContext(BitwithoutlengthContext.class,0); + } + public ConstbitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constbit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstbit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstbit(this); + } + } + + public final ConstbitContext constbit() throws RecognitionException { + ConstbitContext _localctx = new ConstbitContext(_ctx, getState()); + enterRule(_localctx, 1138, RULE_constbit); + try { + setState(8709); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,529,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8707); + bitwithlength(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8708); + bitwithoutlength(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BitwithlengthContext extends ParserRuleContext { + public TerminalNode BIT() { return getToken(PostgreSqlParser.BIT, 0); } + public Opt_varyingContext opt_varying() { + return getRuleContext(Opt_varyingContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public BitwithlengthContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_bitwithlength; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterBitwithlength(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitBitwithlength(this); + } + } + + public final BitwithlengthContext bitwithlength() throws RecognitionException { + BitwithlengthContext _localctx = new BitwithlengthContext(_ctx, getState()); + enterRule(_localctx, 1140, RULE_bitwithlength); + try { + enterOuterAlt(_localctx, 1); + { + setState(8711); + match(BIT); + setState(8712); + opt_varying(); + setState(8713); + match(OPEN_PAREN); + setState(8714); + expr_list(); + setState(8715); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BitwithoutlengthContext extends ParserRuleContext { + public TerminalNode BIT() { return getToken(PostgreSqlParser.BIT, 0); } + public Opt_varyingContext opt_varying() { + return getRuleContext(Opt_varyingContext.class,0); + } + public BitwithoutlengthContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_bitwithoutlength; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterBitwithoutlength(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitBitwithoutlength(this); + } + } + + public final BitwithoutlengthContext bitwithoutlength() throws RecognitionException { + BitwithoutlengthContext _localctx = new BitwithoutlengthContext(_ctx, getState()); + enterRule(_localctx, 1142, RULE_bitwithoutlength); + try { + enterOuterAlt(_localctx, 1); + { + setState(8717); + match(BIT); + setState(8718); + opt_varying(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CharacterContext extends ParserRuleContext { + public Character_cContext character_c() { + return getRuleContext(Character_cContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public CharacterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_character; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCharacter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCharacter(this); + } + } + + public final CharacterContext character() throws RecognitionException { + CharacterContext _localctx = new CharacterContext(_ctx, getState()); + enterRule(_localctx, 1144, RULE_character); + try { + enterOuterAlt(_localctx, 1); + { + setState(8720); + character_c(); + setState(8725); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,530,_ctx) ) { + case 1: + { + setState(8721); + match(OPEN_PAREN); + setState(8722); + iconst(); + setState(8723); + match(CLOSE_PAREN); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstcharacterContext extends ParserRuleContext { + public Character_cContext character_c() { + return getRuleContext(Character_cContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ConstcharacterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constcharacter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstcharacter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstcharacter(this); + } + } + + public final ConstcharacterContext constcharacter() throws RecognitionException { + ConstcharacterContext _localctx = new ConstcharacterContext(_ctx, getState()); + enterRule(_localctx, 1146, RULE_constcharacter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8727); + character_c(); + setState(8732); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(8728); + match(OPEN_PAREN); + setState(8729); + iconst(); + setState(8730); + match(CLOSE_PAREN); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Character_cContext extends ParserRuleContext { + public Opt_varyingContext opt_varying() { + return getRuleContext(Opt_varyingContext.class,0); + } + public TerminalNode CHARACTER() { return getToken(PostgreSqlParser.CHARACTER, 0); } + public TerminalNode CHAR_P() { return getToken(PostgreSqlParser.CHAR_P, 0); } + public TerminalNode NCHAR() { return getToken(PostgreSqlParser.NCHAR, 0); } + public TerminalNode VARCHAR() { return getToken(PostgreSqlParser.VARCHAR, 0); } + public TerminalNode NATIONAL() { return getToken(PostgreSqlParser.NATIONAL, 0); } + public Character_cContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_character_c; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCharacter_c(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCharacter_c(this); + } + } + + public final Character_cContext character_c() throws RecognitionException { + Character_cContext _localctx = new Character_cContext(_ctx, getState()); + enterRule(_localctx, 1148, RULE_character_c); + int _la; + try { + setState(8740); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CHAR_P: + case CHARACTER: + case NCHAR: + enterOuterAlt(_localctx, 1); + { + setState(8734); + _la = _input.LA(1); + if ( !(((((_la - 386)) & ~0x3f) == 0 && ((1L << (_la - 386)) & 32771L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8735); + opt_varying(); + } + break; + case VARCHAR: + enterOuterAlt(_localctx, 2); + { + setState(8736); + match(VARCHAR); + } + break; + case NATIONAL: + enterOuterAlt(_localctx, 3); + { + setState(8737); + match(NATIONAL); + setState(8738); + _la = _input.LA(1); + if ( !(_la==CHAR_P || _la==CHARACTER) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8739); + opt_varying(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_varyingContext extends ParserRuleContext { + public TerminalNode VARYING() { return getToken(PostgreSqlParser.VARYING, 0); } + public Opt_varyingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_varying; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_varying(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_varying(this); + } + } + + public final Opt_varyingContext opt_varying() throws RecognitionException { + Opt_varyingContext _localctx = new Opt_varyingContext(_ctx, getState()); + enterRule(_localctx, 1150, RULE_opt_varying); + try { + setState(8744); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,533,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8742); + match(VARYING); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstdatetimeContext extends ParserRuleContext { + public Opt_timezoneContext opt_timezone() { + return getRuleContext(Opt_timezoneContext.class,0); + } + public TerminalNode TIMESTAMP() { return getToken(PostgreSqlParser.TIMESTAMP, 0); } + public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public ConstdatetimeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constdatetime; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstdatetime(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstdatetime(this); + } + } + + public final ConstdatetimeContext constdatetime() throws RecognitionException { + ConstdatetimeContext _localctx = new ConstdatetimeContext(_ctx, getState()); + enterRule(_localctx, 1152, RULE_constdatetime); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8746); + _la = _input.LA(1); + if ( !(_la==TIME || _la==TIMESTAMP) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8751); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,534,_ctx) ) { + case 1: + { + setState(8747); + match(OPEN_PAREN); + setState(8748); + iconst(); + setState(8749); + match(CLOSE_PAREN); + } + break; + } + setState(8753); + opt_timezone(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ConstintervalContext extends ParserRuleContext { + public TerminalNode INTERVAL() { return getToken(PostgreSqlParser.INTERVAL, 0); } + public ConstintervalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constinterval; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterConstinterval(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitConstinterval(this); + } + } + + public final ConstintervalContext constinterval() throws RecognitionException { + ConstintervalContext _localctx = new ConstintervalContext(_ctx, getState()); + enterRule(_localctx, 1154, RULE_constinterval); + try { + enterOuterAlt(_localctx, 1); + { + setState(8755); + match(INTERVAL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_timezoneContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } + public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } + public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } + public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } + public Opt_timezoneContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_timezone; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_timezone(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_timezone(this); + } + } + + public final Opt_timezoneContext opt_timezone() throws RecognitionException { + Opt_timezoneContext _localctx = new Opt_timezoneContext(_ctx, getState()); + enterRule(_localctx, 1156, RULE_opt_timezone); + try { + setState(8764); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,535,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8757); + match(WITH); + setState(8758); + match(TIME); + setState(8759); + match(ZONE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8760); + match(WITHOUT); + setState(8761); + match(TIME); + setState(8762); + match(ZONE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_intervalContext extends ParserRuleContext { + public TerminalNode YEAR_P() { return getToken(PostgreSqlParser.YEAR_P, 0); } + public TerminalNode MONTH_P() { return getToken(PostgreSqlParser.MONTH_P, 0); } + public TerminalNode DAY_P() { return getToken(PostgreSqlParser.DAY_P, 0); } + public TerminalNode HOUR_P() { return getToken(PostgreSqlParser.HOUR_P, 0); } + public TerminalNode MINUTE_P() { return getToken(PostgreSqlParser.MINUTE_P, 0); } + public Interval_secondContext interval_second() { + return getRuleContext(Interval_secondContext.class,0); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public Opt_intervalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_interval; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_interval(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_interval(this); + } + } + + public final Opt_intervalContext opt_interval() throws RecognitionException { + Opt_intervalContext _localctx = new Opt_intervalContext(_ctx, getState()); + enterRule(_localctx, 1158, RULE_opt_interval); + try { + setState(8792); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,538,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8766); + match(YEAR_P); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8767); + match(MONTH_P); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(8768); + match(DAY_P); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(8769); + match(HOUR_P); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(8770); + match(MINUTE_P); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(8771); + interval_second(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(8772); + match(YEAR_P); + setState(8773); + match(TO); + setState(8774); + match(MONTH_P); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(8775); + match(DAY_P); + setState(8776); + match(TO); + setState(8780); + _errHandler.sync(this); + switch (_input.LA(1)) { + case HOUR_P: + { + setState(8777); + match(HOUR_P); + } + break; + case MINUTE_P: + { + setState(8778); + match(MINUTE_P); + } + break; + case SECOND_P: + { + setState(8779); + interval_second(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(8782); + match(HOUR_P); + setState(8783); + match(TO); + setState(8786); + _errHandler.sync(this); + switch (_input.LA(1)) { + case MINUTE_P: + { + setState(8784); + match(MINUTE_P); + } + break; + case SECOND_P: + { + setState(8785); + interval_second(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(8788); + match(MINUTE_P); + setState(8789); + match(TO); + setState(8790); + interval_second(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Interval_secondContext extends ParserRuleContext { + public TerminalNode SECOND_P() { return getToken(PostgreSqlParser.SECOND_P, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Interval_secondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interval_second; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInterval_second(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInterval_second(this); + } + } + + public final Interval_secondContext interval_second() throws RecognitionException { + Interval_secondContext _localctx = new Interval_secondContext(_ctx, getState()); + enterRule(_localctx, 1160, RULE_interval_second); + try { + enterOuterAlt(_localctx, 1); + { + setState(8794); + match(SECOND_P); + setState(8799); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,539,_ctx) ) { + case 1: + { + setState(8795); + match(OPEN_PAREN); + setState(8796); + iconst(); + setState(8797); + match(CLOSE_PAREN); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_escapeContext extends ParserRuleContext { + public TerminalNode ESCAPE() { return getToken(PostgreSqlParser.ESCAPE, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Opt_escapeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_escape; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_escape(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_escape(this); + } + } + + public final Opt_escapeContext opt_escape() throws RecognitionException { + Opt_escapeContext _localctx = new Opt_escapeContext(_ctx, getState()); + enterRule(_localctx, 1162, RULE_opt_escape); + try { + setState(8804); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,540,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8801); + match(ESCAPE); + setState(8802); + a_expr(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_exprContext extends ParserRuleContext { + public A_expr_qualContext a_expr_qual() { + return getRuleContext(A_expr_qualContext.class,0); + } + public A_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr(this); + } + } + + public final A_exprContext a_expr() throws RecognitionException { + A_exprContext _localctx = new A_exprContext(_ctx, getState()); + enterRule(_localctx, 1164, RULE_a_expr); + try { + enterOuterAlt(_localctx, 1); + { + setState(8806); + a_expr_qual(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_qualContext extends ParserRuleContext { + public A_expr_lesslessContext a_expr_lessless() { + return getRuleContext(A_expr_lesslessContext.class,0); + } + public Qual_opContext qual_op() { + return getRuleContext(Qual_opContext.class,0); + } + public A_expr_qualContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_qual; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_qual(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_qual(this); + } + } + + public final A_expr_qualContext a_expr_qual() throws RecognitionException { + A_expr_qualContext _localctx = new A_expr_qualContext(_ctx, getState()); + enterRule(_localctx, 1166, RULE_a_expr_qual); + try { + enterOuterAlt(_localctx, 1); + { + setState(8808); + a_expr_lessless(); + setState(8810); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,541,_ctx) ) { + case 1: + { + setState(8809); + qual_op(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_lesslessContext extends ParserRuleContext { + public List a_expr_or() { + return getRuleContexts(A_expr_orContext.class); + } + public A_expr_orContext a_expr_or(int i) { + return getRuleContext(A_expr_orContext.class,i); + } + public List LESS_LESS() { return getTokens(PostgreSqlParser.LESS_LESS); } + public TerminalNode LESS_LESS(int i) { + return getToken(PostgreSqlParser.LESS_LESS, i); + } + public List GREATER_GREATER() { return getTokens(PostgreSqlParser.GREATER_GREATER); } + public TerminalNode GREATER_GREATER(int i) { + return getToken(PostgreSqlParser.GREATER_GREATER, i); + } + public A_expr_lesslessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_lessless; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_lessless(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_lessless(this); + } + } + + public final A_expr_lesslessContext a_expr_lessless() throws RecognitionException { + A_expr_lesslessContext _localctx = new A_expr_lesslessContext(_ctx, getState()); + enterRule(_localctx, 1168, RULE_a_expr_lessless); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8812); + a_expr_or(); + setState(8817); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,542,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8813); + _la = _input.LA(1); + if ( !(_la==LESS_LESS || _la==GREATER_GREATER) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8814); + a_expr_or(); + } + } + } + setState(8819); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,542,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_orContext extends ParserRuleContext { + public List a_expr_and() { + return getRuleContexts(A_expr_andContext.class); + } + public A_expr_andContext a_expr_and(int i) { + return getRuleContext(A_expr_andContext.class,i); + } + public List OR() { return getTokens(PostgreSqlParser.OR); } + public TerminalNode OR(int i) { + return getToken(PostgreSqlParser.OR, i); + } + public A_expr_orContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_or; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_or(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_or(this); + } + } + + public final A_expr_orContext a_expr_or() throws RecognitionException { + A_expr_orContext _localctx = new A_expr_orContext(_ctx, getState()); + enterRule(_localctx, 1170, RULE_a_expr_or); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8820); + a_expr_and(); + setState(8825); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,543,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8821); + match(OR); + setState(8822); + a_expr_and(); + } + } + } + setState(8827); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,543,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_andContext extends ParserRuleContext { + public List a_expr_between() { + return getRuleContexts(A_expr_betweenContext.class); + } + public A_expr_betweenContext a_expr_between(int i) { + return getRuleContext(A_expr_betweenContext.class,i); + } + public List AND() { return getTokens(PostgreSqlParser.AND); } + public TerminalNode AND(int i) { + return getToken(PostgreSqlParser.AND, i); + } + public A_expr_andContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_and; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_and(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_and(this); + } + } + + public final A_expr_andContext a_expr_and() throws RecognitionException { + A_expr_andContext _localctx = new A_expr_andContext(_ctx, getState()); + enterRule(_localctx, 1172, RULE_a_expr_and); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8828); + a_expr_between(); + setState(8833); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,544,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8829); + match(AND); + setState(8830); + a_expr_between(); + } + } + } + setState(8835); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,544,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_betweenContext extends ParserRuleContext { + public List a_expr_in() { + return getRuleContexts(A_expr_inContext.class); + } + public A_expr_inContext a_expr_in(int i) { + return getRuleContext(A_expr_inContext.class,i); + } + public TerminalNode BETWEEN() { return getToken(PostgreSqlParser.BETWEEN, 0); } + public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode SYMMETRIC() { return getToken(PostgreSqlParser.SYMMETRIC, 0); } + public A_expr_betweenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_between; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_between(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_between(this); + } + } + + public final A_expr_betweenContext a_expr_between() throws RecognitionException { + A_expr_betweenContext _localctx = new A_expr_betweenContext(_ctx, getState()); + enterRule(_localctx, 1174, RULE_a_expr_between); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8836); + a_expr_in(); + setState(8848); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,547,_ctx) ) { + case 1: + { + setState(8838); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(8837); + match(NOT); + } + } + + setState(8840); + match(BETWEEN); + setState(8842); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SYMMETRIC) { + { + setState(8841); + match(SYMMETRIC); + } + } + + setState(8844); + a_expr_in(); + setState(8845); + match(AND); + setState(8846); + a_expr_in(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_inContext extends ParserRuleContext { + public A_expr_unary_notContext a_expr_unary_not() { + return getRuleContext(A_expr_unary_notContext.class,0); + } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public In_exprContext in_expr() { + return getRuleContext(In_exprContext.class,0); + } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public A_expr_inContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_in; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_in(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_in(this); + } + } + + public final A_expr_inContext a_expr_in() throws RecognitionException { + A_expr_inContext _localctx = new A_expr_inContext(_ctx, getState()); + enterRule(_localctx, 1176, RULE_a_expr_in); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8850); + a_expr_unary_not(); + setState(8856); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,549,_ctx) ) { + case 1: + { + setState(8852); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(8851); + match(NOT); + } + } + + setState(8854); + match(IN_P); + setState(8855); + in_expr(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_unary_notContext extends ParserRuleContext { + public A_expr_isnullContext a_expr_isnull() { + return getRuleContext(A_expr_isnullContext.class,0); + } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public A_expr_unary_notContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_unary_not; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_unary_not(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_unary_not(this); + } + } + + public final A_expr_unary_notContext a_expr_unary_not() throws RecognitionException { + A_expr_unary_notContext _localctx = new A_expr_unary_notContext(_ctx, getState()); + enterRule(_localctx, 1178, RULE_a_expr_unary_not); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8859); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(8858); + match(NOT); + } + } + + setState(8861); + a_expr_isnull(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_isnullContext extends ParserRuleContext { + public A_expr_is_notContext a_expr_is_not() { + return getRuleContext(A_expr_is_notContext.class,0); + } + public TerminalNode ISNULL() { return getToken(PostgreSqlParser.ISNULL, 0); } + public TerminalNode NOTNULL() { return getToken(PostgreSqlParser.NOTNULL, 0); } + public A_expr_isnullContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_isnull; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_isnull(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_isnull(this); + } + } + + public final A_expr_isnullContext a_expr_isnull() throws RecognitionException { + A_expr_isnullContext _localctx = new A_expr_isnullContext(_ctx, getState()); + enterRule(_localctx, 1180, RULE_a_expr_isnull); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8863); + a_expr_is_not(); + setState(8865); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,551,_ctx) ) { + case 1: + { + setState(8864); + _la = _input.LA(1); + if ( !(_la==ISNULL || _la==NOTNULL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_is_notContext extends ParserRuleContext { + public A_expr_compareContext a_expr_compare() { + return getRuleContext(A_expr_compareContext.class,0); + } + public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode TRUE_P() { return getToken(PostgreSqlParser.TRUE_P, 0); } + public TerminalNode FALSE_P() { return getToken(PostgreSqlParser.FALSE_P, 0); } + public TerminalNode UNKNOWN() { return getToken(PostgreSqlParser.UNKNOWN, 0); } + public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Type_listContext type_list() { + return getRuleContext(Type_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode DOCUMENT_P() { return getToken(PostgreSqlParser.DOCUMENT_P, 0); } + public TerminalNode NORMALIZED() { return getToken(PostgreSqlParser.NORMALIZED, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public Unicode_normal_formContext unicode_normal_form() { + return getRuleContext(Unicode_normal_formContext.class,0); + } + public A_expr_is_notContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_is_not; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_is_not(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_is_not(this); + } + } + + public final A_expr_is_notContext a_expr_is_not() throws RecognitionException { + A_expr_is_notContext _localctx = new A_expr_is_notContext(_ctx, getState()); + enterRule(_localctx, 1182, RULE_a_expr_is_not); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8867); + a_expr_compare(); + setState(8891); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,555,_ctx) ) { + case 1: + { + setState(8868); + match(IS); + setState(8870); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(8869); + match(NOT); + } + } + + setState(8889); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NULL_P: + { + setState(8872); + match(NULL_P); + } + break; + case TRUE_P: + { + setState(8873); + match(TRUE_P); + } + break; + case FALSE_P: + { + setState(8874); + match(FALSE_P); + } + break; + case UNKNOWN: + { + setState(8875); + match(UNKNOWN); + } + break; + case DISTINCT: + { + setState(8876); + match(DISTINCT); + setState(8877); + match(FROM); + setState(8878); + a_expr(); + } + break; + case OF: + { + setState(8879); + match(OF); + setState(8880); + match(OPEN_PAREN); + setState(8881); + type_list(); + setState(8882); + match(CLOSE_PAREN); + } + break; + case DOCUMENT_P: + { + setState(8884); + match(DOCUMENT_P); + } + break; + case NORMALIZED: + case NFC: + case NFD: + case NFKC: + case NFKD: + { + setState(8886); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 485)) & ~0x3f) == 0 && ((1L << (_la - 485)) & 15L) != 0)) { + { + setState(8885); + unicode_normal_form(); + } + } + + setState(8888); + match(NORMALIZED); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_compareContext extends ParserRuleContext { + public List a_expr_like() { + return getRuleContexts(A_expr_likeContext.class); + } + public A_expr_likeContext a_expr_like(int i) { + return getRuleContext(A_expr_likeContext.class,i); + } + public Subquery_OpContext subquery_Op() { + return getRuleContext(Subquery_OpContext.class,0); + } + public Sub_typeContext sub_type() { + return getRuleContext(Sub_typeContext.class,0); + } + public TerminalNode LT() { return getToken(PostgreSqlParser.LT, 0); } + public TerminalNode GT() { return getToken(PostgreSqlParser.GT, 0); } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public TerminalNode LESS_EQUALS() { return getToken(PostgreSqlParser.LESS_EQUALS, 0); } + public TerminalNode GREATER_EQUALS() { return getToken(PostgreSqlParser.GREATER_EQUALS, 0); } + public TerminalNode NOT_EQUALS() { return getToken(PostgreSqlParser.NOT_EQUALS, 0); } + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public A_expr_compareContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_compare; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_compare(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_compare(this); + } + } + + public final A_expr_compareContext a_expr_compare() throws RecognitionException { + A_expr_compareContext _localctx = new A_expr_compareContext(_ctx, getState()); + enterRule(_localctx, 1184, RULE_a_expr_compare); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8893); + a_expr_like(); + setState(8905); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,557,_ctx) ) { + case 1: + { + setState(8894); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 176951296L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8895); + a_expr_like(); + } + break; + case 2: + { + setState(8896); + subquery_Op(); + setState(8897); + sub_type(); + setState(8903); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,556,_ctx) ) { + case 1: + { + setState(8898); + select_with_parens(); + } + break; + case 2: + { + setState(8899); + match(OPEN_PAREN); + setState(8900); + a_expr(); + setState(8901); + match(CLOSE_PAREN); + } + break; + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_likeContext extends ParserRuleContext { + public List a_expr_qual_op() { + return getRuleContexts(A_expr_qual_opContext.class); + } + public A_expr_qual_opContext a_expr_qual_op(int i) { + return getRuleContext(A_expr_qual_opContext.class,i); + } + public Opt_escapeContext opt_escape() { + return getRuleContext(Opt_escapeContext.class,0); + } + public TerminalNode LIKE() { return getToken(PostgreSqlParser.LIKE, 0); } + public TerminalNode ILIKE() { return getToken(PostgreSqlParser.ILIKE, 0); } + public TerminalNode SIMILAR() { return getToken(PostgreSqlParser.SIMILAR, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public A_expr_likeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_like; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_like(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_like(this); + } + } + + public final A_expr_likeContext a_expr_like() throws RecognitionException { + A_expr_likeContext _localctx = new A_expr_likeContext(_ctx, getState()); + enterRule(_localctx, 1186, RULE_a_expr_like); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8907); + a_expr_qual_op(); + setState(8920); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,560,_ctx) ) { + case 1: + { + setState(8909); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(8908); + match(NOT); + } + } + + setState(8915); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LIKE: + { + setState(8911); + match(LIKE); + } + break; + case ILIKE: + { + setState(8912); + match(ILIKE); + } + break; + case SIMILAR: + { + setState(8913); + match(SIMILAR); + setState(8914); + match(TO); + } + break; + default: + throw new NoViableAltException(this); + } + setState(8917); + a_expr_qual_op(); + setState(8918); + opt_escape(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_qual_opContext extends ParserRuleContext { + public List a_expr_unary_qualop() { + return getRuleContexts(A_expr_unary_qualopContext.class); + } + public A_expr_unary_qualopContext a_expr_unary_qualop(int i) { + return getRuleContext(A_expr_unary_qualopContext.class,i); + } + public List qual_op() { + return getRuleContexts(Qual_opContext.class); + } + public Qual_opContext qual_op(int i) { + return getRuleContext(Qual_opContext.class,i); + } + public A_expr_qual_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_qual_op; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_qual_op(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_qual_op(this); + } + } + + public final A_expr_qual_opContext a_expr_qual_op() throws RecognitionException { + A_expr_qual_opContext _localctx = new A_expr_qual_opContext(_ctx, getState()); + enterRule(_localctx, 1188, RULE_a_expr_qual_op); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8922); + a_expr_unary_qualop(); + setState(8928); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,561,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8923); + qual_op(); + setState(8924); + a_expr_unary_qualop(); + } + } + } + setState(8930); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,561,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_unary_qualopContext extends ParserRuleContext { + public ParameterContext parameter() { + return getRuleContext(ParameterContext.class,0); + } + public A_expr_addContext a_expr_add() { + return getRuleContext(A_expr_addContext.class,0); + } + public Qual_opContext qual_op() { + return getRuleContext(Qual_opContext.class,0); + } + public A_expr_unary_qualopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_unary_qualop; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_unary_qualop(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_unary_qualop(this); + } + } + + public final A_expr_unary_qualopContext a_expr_unary_qualop() throws RecognitionException { + A_expr_unary_qualopContext _localctx = new A_expr_unary_qualopContext(_ctx, getState()); + enterRule(_localctx, 1190, RULE_a_expr_unary_qualop); + try { + setState(8936); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,563,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(8931); + parameter(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(8933); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,562,_ctx) ) { + case 1: + { + setState(8932); + qual_op(); + } + break; + } + setState(8935); + a_expr_add(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_addContext extends ParserRuleContext { + public List a_expr_mul() { + return getRuleContexts(A_expr_mulContext.class); + } + public A_expr_mulContext a_expr_mul(int i) { + return getRuleContext(A_expr_mulContext.class,i); + } + public List MINUS() { return getTokens(PostgreSqlParser.MINUS); } + public TerminalNode MINUS(int i) { + return getToken(PostgreSqlParser.MINUS, i); + } + public List PLUS() { return getTokens(PostgreSqlParser.PLUS); } + public TerminalNode PLUS(int i) { + return getToken(PostgreSqlParser.PLUS, i); + } + public A_expr_addContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_add; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_add(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_add(this); + } + } + + public final A_expr_addContext a_expr_add() throws RecognitionException { + A_expr_addContext _localctx = new A_expr_addContext(_ctx, getState()); + enterRule(_localctx, 1192, RULE_a_expr_add); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8938); + a_expr_mul(); + setState(8943); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,564,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8939); + _la = _input.LA(1); + if ( !(_la==PLUS || _la==MINUS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8940); + a_expr_mul(); + } + } + } + setState(8945); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,564,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_mulContext extends ParserRuleContext { + public List a_expr_caret() { + return getRuleContexts(A_expr_caretContext.class); + } + public A_expr_caretContext a_expr_caret(int i) { + return getRuleContext(A_expr_caretContext.class,i); + } + public List STAR() { return getTokens(PostgreSqlParser.STAR); } + public TerminalNode STAR(int i) { + return getToken(PostgreSqlParser.STAR, i); + } + public List SLASH() { return getTokens(PostgreSqlParser.SLASH); } + public TerminalNode SLASH(int i) { + return getToken(PostgreSqlParser.SLASH, i); + } + public List PERCENT() { return getTokens(PostgreSqlParser.PERCENT); } + public TerminalNode PERCENT(int i) { + return getToken(PostgreSqlParser.PERCENT, i); + } + public A_expr_mulContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_mul; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_mul(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_mul(this); + } + } + + public final A_expr_mulContext a_expr_mul() throws RecognitionException { + A_expr_mulContext _localctx = new A_expr_mulContext(_ctx, getState()); + enterRule(_localctx, 1194, RULE_a_expr_mul); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8946); + a_expr_caret(); + setState(8951); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,565,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(8947); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 536938496L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8948); + a_expr_caret(); + } + } + } + setState(8953); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,565,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_caretContext extends ParserRuleContext { + public A_expr_unary_signContext a_expr_unary_sign() { + return getRuleContext(A_expr_unary_signContext.class,0); + } + public TerminalNode CARET() { return getToken(PostgreSqlParser.CARET, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public A_expr_caretContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_caret; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_caret(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_caret(this); + } + } + + public final A_expr_caretContext a_expr_caret() throws RecognitionException { + A_expr_caretContext _localctx = new A_expr_caretContext(_ctx, getState()); + enterRule(_localctx, 1196, RULE_a_expr_caret); + try { + enterOuterAlt(_localctx, 1); + { + setState(8954); + a_expr_unary_sign(); + setState(8957); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,566,_ctx) ) { + case 1: + { + setState(8955); + match(CARET); + setState(8956); + a_expr(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_unary_signContext extends ParserRuleContext { + public A_expr_at_time_zoneContext a_expr_at_time_zone() { + return getRuleContext(A_expr_at_time_zoneContext.class,0); + } + public TerminalNode MINUS() { return getToken(PostgreSqlParser.MINUS, 0); } + public TerminalNode PLUS() { return getToken(PostgreSqlParser.PLUS, 0); } + public A_expr_unary_signContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_unary_sign; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_unary_sign(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_unary_sign(this); + } + } + + public final A_expr_unary_signContext a_expr_unary_sign() throws RecognitionException { + A_expr_unary_signContext _localctx = new A_expr_unary_signContext(_ctx, getState()); + enterRule(_localctx, 1198, RULE_a_expr_unary_sign); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8960); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PLUS || _la==MINUS) { + { + setState(8959); + _la = _input.LA(1); + if ( !(_la==PLUS || _la==MINUS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(8962); + a_expr_at_time_zone(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_at_time_zoneContext extends ParserRuleContext { + public A_expr_collateContext a_expr_collate() { + return getRuleContext(A_expr_collateContext.class,0); + } + public TerminalNode AT() { return getToken(PostgreSqlParser.AT, 0); } + public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } + public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public A_expr_at_time_zoneContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_at_time_zone; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_at_time_zone(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_at_time_zone(this); + } + } + + public final A_expr_at_time_zoneContext a_expr_at_time_zone() throws RecognitionException { + A_expr_at_time_zoneContext _localctx = new A_expr_at_time_zoneContext(_ctx, getState()); + enterRule(_localctx, 1200, RULE_a_expr_at_time_zone); + try { + enterOuterAlt(_localctx, 1); + { + setState(8964); + a_expr_collate(); + setState(8969); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,568,_ctx) ) { + case 1: + { + setState(8965); + match(AT); + setState(8966); + match(TIME); + setState(8967); + match(ZONE); + setState(8968); + a_expr(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_collateContext extends ParserRuleContext { + public A_expr_typecastContext a_expr_typecast() { + return getRuleContext(A_expr_typecastContext.class,0); + } + public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public A_expr_collateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_collate; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_collate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_collate(this); + } + } + + public final A_expr_collateContext a_expr_collate() throws RecognitionException { + A_expr_collateContext _localctx = new A_expr_collateContext(_ctx, getState()); + enterRule(_localctx, 1202, RULE_a_expr_collate); + try { + enterOuterAlt(_localctx, 1); + { + setState(8971); + a_expr_typecast(); + setState(8974); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,569,_ctx) ) { + case 1: + { + setState(8972); + match(COLLATE); + setState(8973); + any_name(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class A_expr_typecastContext extends ParserRuleContext { + public C_exprContext c_expr() { + return getRuleContext(C_exprContext.class,0); + } + public List TYPECAST() { return getTokens(PostgreSqlParser.TYPECAST); } + public TerminalNode TYPECAST(int i) { + return getToken(PostgreSqlParser.TYPECAST, i); + } + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public A_expr_typecastContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_a_expr_typecast; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterA_expr_typecast(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitA_expr_typecast(this); + } + } + + public final A_expr_typecastContext a_expr_typecast() throws RecognitionException { + A_expr_typecastContext _localctx = new A_expr_typecastContext(_ctx, getState()); + enterRule(_localctx, 1204, RULE_a_expr_typecast); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(8976); + c_expr(); + setState(8981); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==TYPECAST) { + { + { + setState(8977); + match(TYPECAST); + setState(8978); + typename(); + } + } + setState(8983); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class B_exprContext extends ParserRuleContext { + public C_exprContext c_expr() { + return getRuleContext(C_exprContext.class,0); + } + public List b_expr() { + return getRuleContexts(B_exprContext.class); + } + public B_exprContext b_expr(int i) { + return getRuleContext(B_exprContext.class,i); + } + public TerminalNode PLUS() { return getToken(PostgreSqlParser.PLUS, 0); } + public TerminalNode MINUS() { return getToken(PostgreSqlParser.MINUS, 0); } + public Qual_opContext qual_op() { + return getRuleContext(Qual_opContext.class,0); + } + public TerminalNode CARET() { return getToken(PostgreSqlParser.CARET, 0); } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public TerminalNode SLASH() { return getToken(PostgreSqlParser.SLASH, 0); } + public TerminalNode PERCENT() { return getToken(PostgreSqlParser.PERCENT, 0); } + public TerminalNode LT() { return getToken(PostgreSqlParser.LT, 0); } + public TerminalNode GT() { return getToken(PostgreSqlParser.GT, 0); } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public TerminalNode LESS_EQUALS() { return getToken(PostgreSqlParser.LESS_EQUALS, 0); } + public TerminalNode GREATER_EQUALS() { return getToken(PostgreSqlParser.GREATER_EQUALS, 0); } + public TerminalNode NOT_EQUALS() { return getToken(PostgreSqlParser.NOT_EQUALS, 0); } + public TerminalNode TYPECAST() { return getToken(PostgreSqlParser.TYPECAST, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } + public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Type_listContext type_list() { + return getRuleContext(Type_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode DOCUMENT_P() { return getToken(PostgreSqlParser.DOCUMENT_P, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public B_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_b_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterB_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitB_expr(this); + } + } + + public final B_exprContext b_expr() throws RecognitionException { + return b_expr(0); + } + + private B_exprContext b_expr(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + B_exprContext _localctx = new B_exprContext(_ctx, _parentState); + B_exprContext _prevctx = _localctx; + int _startState = 1206; + enterRecursionRule(_localctx, 1206, RULE_b_expr, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(8991); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,571,_ctx) ) { + case 1: + { + setState(8985); + c_expr(); + } + break; + case 2: + { + setState(8986); + _la = _input.LA(1); + if ( !(_la==PLUS || _la==MINUS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8987); + b_expr(9); + } + break; + case 3: + { + setState(8988); + qual_op(); + setState(8989); + b_expr(3); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(9032); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,575,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(9030); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,574,_ctx) ) { + case 1: + { + _localctx = new B_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_b_expr); + setState(8993); + if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(8994); + match(CARET); + setState(8995); + b_expr(9); + } + break; + case 2: + { + _localctx = new B_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_b_expr); + setState(8996); + if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(8997); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 536938496L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(8998); + b_expr(8); + } + break; + case 3: + { + _localctx = new B_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_b_expr); + setState(8999); + if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(9000); + _la = _input.LA(1); + if ( !(_la==PLUS || _la==MINUS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(9001); + b_expr(7); + } + break; + case 4: + { + _localctx = new B_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_b_expr); + setState(9002); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(9003); + qual_op(); + setState(9004); + b_expr(6); + } + break; + case 5: + { + _localctx = new B_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_b_expr); + setState(9006); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(9007); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 176951296L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(9008); + b_expr(5); + } + break; + case 6: + { + _localctx = new B_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_b_expr); + setState(9009); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(9010); + match(TYPECAST); + setState(9011); + typename(); + } + break; + case 7: + { + _localctx = new B_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_b_expr); + setState(9012); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(9013); + qual_op(); + } + break; + case 8: + { + _localctx = new B_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_b_expr); + setState(9014); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(9015); + match(IS); + setState(9017); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(9016); + match(NOT); + } + } + + setState(9028); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DISTINCT: + { + setState(9019); + match(DISTINCT); + setState(9020); + match(FROM); + setState(9021); + b_expr(0); + } + break; + case OF: + { + setState(9022); + match(OF); + setState(9023); + match(OPEN_PAREN); + setState(9024); + type_list(); + setState(9025); + match(CLOSE_PAREN); + } + break; + case DOCUMENT_P: + { + setState(9027); + match(DOCUMENT_P); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } + } + setState(9034); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,575,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class C_exprContext extends ParserRuleContext { + public C_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_c_expr; } + + public C_exprContext() { } + public void copyFrom(C_exprContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class C_expr_existsContext extends C_exprContext { + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public C_expr_existsContext(C_exprContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterC_expr_exists(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitC_expr_exists(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class C_expr_caseContext extends C_exprContext { + public Case_exprContext case_expr() { + return getRuleContext(Case_exprContext.class,0); + } + public C_expr_caseContext(C_exprContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterC_expr_case(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitC_expr_case(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class C_expr_exprContext extends C_exprContext { + public A_exprContext a_expr_in_parens; + public TerminalNode ARRAY() { return getToken(PostgreSqlParser.ARRAY, 0); } + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public Array_exprContext array_expr() { + return getRuleContext(Array_exprContext.class,0); + } + public TerminalNode PARAM() { return getToken(PostgreSqlParser.PARAM, 0); } + public Opt_indirectionContext opt_indirection() { + return getRuleContext(Opt_indirectionContext.class,0); + } + public TerminalNode GROUPING() { return getToken(PostgreSqlParser.GROUPING, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode UNIQUE() { return getToken(PostgreSqlParser.UNIQUE, 0); } + public ParameterContext parameter() { + return getRuleContext(ParameterContext.class,0); + } + public ColumnrefContext columnref() { + return getRuleContext(ColumnrefContext.class,0); + } + public AexprconstContext aexprconst() { + return getRuleContext(AexprconstContext.class,0); + } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Func_exprContext func_expr() { + return getRuleContext(Func_exprContext.class,0); + } + public IndirectionContext indirection() { + return getRuleContext(IndirectionContext.class,0); + } + public Explicit_rowContext explicit_row() { + return getRuleContext(Explicit_rowContext.class,0); + } + public Implicit_rowContext implicit_row() { + return getRuleContext(Implicit_rowContext.class,0); + } + public List row() { + return getRuleContexts(RowContext.class); + } + public RowContext row(int i) { + return getRuleContext(RowContext.class,i); + } + public TerminalNode OVERLAPS() { return getToken(PostgreSqlParser.OVERLAPS, 0); } + public C_expr_exprContext(C_exprContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterC_expr_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitC_expr_expr(this); + } + } + + public final C_exprContext c_expr() throws RecognitionException { + C_exprContext _localctx = new C_exprContext(_ctx, getState()); + enterRule(_localctx, 1208, RULE_c_expr); + try { + setState(9071); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,578,_ctx) ) { + case 1: + _localctx = new C_expr_existsContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(9035); + match(EXISTS); + setState(9036); + select_with_parens(); + } + break; + case 2: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(9037); + match(ARRAY); + setState(9040); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + { + setState(9038); + select_with_parens(); + } + break; + case OPEN_BRACKET: + { + setState(9039); + array_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 3); + { + setState(9042); + match(PARAM); + setState(9043); + opt_indirection(); + } + break; + case 4: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 4); + { + setState(9044); + match(GROUPING); + setState(9045); + match(OPEN_PAREN); + setState(9046); + expr_list(); + setState(9047); + match(CLOSE_PAREN); + } + break; + case 5: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(9049); + match(UNIQUE); + setState(9050); + select_with_parens(); + } + break; + case 6: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 6); + { + setState(9051); + parameter(); + } + break; + case 7: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 7); + { + setState(9052); + columnref(); + } + break; + case 8: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 8); + { + setState(9053); + aexprconst(); + } + break; + case 9: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 9); + { + setState(9054); + match(OPEN_PAREN); + setState(9055); + ((C_expr_exprContext)_localctx).a_expr_in_parens = a_expr(); + setState(9056); + match(CLOSE_PAREN); + setState(9057); + opt_indirection(); + } + break; + case 10: + _localctx = new C_expr_caseContext(_localctx); + enterOuterAlt(_localctx, 10); + { + setState(9059); + case_expr(); + } + break; + case 11: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 11); + { + setState(9060); + func_expr(); + } + break; + case 12: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 12); + { + setState(9061); + select_with_parens(); + setState(9063); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,577,_ctx) ) { + case 1: + { + setState(9062); + indirection(); + } + break; + } + } + break; + case 13: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 13); + { + setState(9065); + explicit_row(); + } + break; + case 14: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 14); + { + setState(9066); + implicit_row(); + } + break; + case 15: + _localctx = new C_expr_exprContext(_localctx); + enterOuterAlt(_localctx, 15); + { + setState(9067); + row(); + setState(9068); + match(OVERLAPS); + setState(9069); + row(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_applicationContext extends ParserRuleContext { + public Func_nameContext func_name() { + return getRuleContext(Func_nameContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Func_arg_listContext func_arg_list() { + return getRuleContext(Func_arg_listContext.class,0); + } + public Opt_sort_clauseContext opt_sort_clause() { + return getRuleContext(Opt_sort_clauseContext.class,0); + } + public TerminalNode VARIADIC() { return getToken(PostgreSqlParser.VARIADIC, 0); } + public Func_arg_exprContext func_arg_expr() { + return getRuleContext(Func_arg_exprContext.class,0); + } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public Func_applicationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_application; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_application(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_application(this); + } + } + + public final Func_applicationContext func_application() throws RecognitionException { + Func_applicationContext _localctx = new Func_applicationContext(_ctx, getState()); + enterRule(_localctx, 1210, RULE_func_application); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9073); + func_name(); + setState(9074); + match(OPEN_PAREN); + setState(9093); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case COLON: + case QUESTION: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNIQUE: + case USER: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + { + setState(9075); + func_arg_list(); + setState(9079); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(9076); + match(COMMA); + setState(9077); + match(VARIADIC); + setState(9078); + func_arg_expr(); + } + } + + setState(9081); + opt_sort_clause(); + } + break; + case VARIADIC: + { + setState(9083); + match(VARIADIC); + setState(9084); + func_arg_expr(); + setState(9085); + opt_sort_clause(); + } + break; + case ALL: + case DISTINCT: + { + setState(9087); + _la = _input.LA(1); + if ( !(_la==ALL || _la==DISTINCT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(9088); + func_arg_list(); + setState(9089); + opt_sort_clause(); + } + break; + case STAR: + { + setState(9091); + match(STAR); + } + break; + case CLOSE_PAREN: + { + } + break; + default: + throw new NoViableAltException(this); + } + setState(9095); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_exprContext extends ParserRuleContext { + public Func_applicationContext func_application() { + return getRuleContext(Func_applicationContext.class,0); + } + public Within_group_clauseContext within_group_clause() { + return getRuleContext(Within_group_clauseContext.class,0); + } + public Filter_clauseContext filter_clause() { + return getRuleContext(Filter_clauseContext.class,0); + } + public Over_clauseContext over_clause() { + return getRuleContext(Over_clauseContext.class,0); + } + public Func_expr_common_subexprContext func_expr_common_subexpr() { + return getRuleContext(Func_expr_common_subexprContext.class,0); + } + public Func_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_expr(this); + } + } + + public final Func_exprContext func_expr() throws RecognitionException { + Func_exprContext _localctx = new Func_exprContext(_ctx, getState()); + enterRule(_localctx, 1212, RULE_func_expr); + try { + setState(9103); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,581,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9097); + func_application(); + setState(9098); + within_group_clause(); + setState(9099); + filter_clause(); + setState(9100); + over_clause(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9102); + func_expr_common_subexpr(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_expr_windowlessContext extends ParserRuleContext { + public Func_applicationContext func_application() { + return getRuleContext(Func_applicationContext.class,0); + } + public Func_expr_common_subexprContext func_expr_common_subexpr() { + return getRuleContext(Func_expr_common_subexprContext.class,0); + } + public Func_expr_windowlessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_expr_windowless; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_expr_windowless(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_expr_windowless(this); + } + } + + public final Func_expr_windowlessContext func_expr_windowless() throws RecognitionException { + Func_expr_windowlessContext _localctx = new Func_expr_windowlessContext(_ctx, getState()); + enterRule(_localctx, 1214, RULE_func_expr_windowless); + try { + setState(9107); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,582,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9105); + func_application(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9106); + func_expr_common_subexpr(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_expr_common_subexprContext extends ParserRuleContext { + public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public List a_expr() { + return getRuleContexts(A_exprContext.class); + } + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode CURRENT_DATE() { return getToken(PostgreSqlParser.CURRENT_DATE, 0); } + public TerminalNode CURRENT_TIME() { return getToken(PostgreSqlParser.CURRENT_TIME, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode CURRENT_TIMESTAMP() { return getToken(PostgreSqlParser.CURRENT_TIMESTAMP, 0); } + public TerminalNode LOCALTIME() { return getToken(PostgreSqlParser.LOCALTIME, 0); } + public TerminalNode LOCALTIMESTAMP() { return getToken(PostgreSqlParser.LOCALTIMESTAMP, 0); } + public TerminalNode CURRENT_ROLE() { return getToken(PostgreSqlParser.CURRENT_ROLE, 0); } + public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } + public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode CURRENT_CATALOG() { return getToken(PostgreSqlParser.CURRENT_CATALOG, 0); } + public TerminalNode CURRENT_SCHEMA() { return getToken(PostgreSqlParser.CURRENT_SCHEMA, 0); } + public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public TerminalNode EXTRACT() { return getToken(PostgreSqlParser.EXTRACT, 0); } + public Extract_listContext extract_list() { + return getRuleContext(Extract_listContext.class,0); + } + public TerminalNode NORMALIZE() { return getToken(PostgreSqlParser.NORMALIZE, 0); } + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public Unicode_normal_formContext unicode_normal_form() { + return getRuleContext(Unicode_normal_formContext.class,0); + } + public TerminalNode OVERLAY() { return getToken(PostgreSqlParser.OVERLAY, 0); } + public Overlay_listContext overlay_list() { + return getRuleContext(Overlay_listContext.class,0); + } + public TerminalNode POSITION() { return getToken(PostgreSqlParser.POSITION, 0); } + public Position_listContext position_list() { + return getRuleContext(Position_listContext.class,0); + } + public TerminalNode SUBSTRING() { return getToken(PostgreSqlParser.SUBSTRING, 0); } + public Substr_listContext substr_list() { + return getRuleContext(Substr_listContext.class,0); + } + public TerminalNode TREAT() { return getToken(PostgreSqlParser.TREAT, 0); } + public TerminalNode TRIM() { return getToken(PostgreSqlParser.TRIM, 0); } + public Trim_listContext trim_list() { + return getRuleContext(Trim_listContext.class,0); + } + public TerminalNode BOTH() { return getToken(PostgreSqlParser.BOTH, 0); } + public TerminalNode LEADING() { return getToken(PostgreSqlParser.LEADING, 0); } + public TerminalNode TRAILING() { return getToken(PostgreSqlParser.TRAILING, 0); } + public TerminalNode NULLIF() { return getToken(PostgreSqlParser.NULLIF, 0); } + public TerminalNode COALESCE() { return getToken(PostgreSqlParser.COALESCE, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode GREATEST() { return getToken(PostgreSqlParser.GREATEST, 0); } + public TerminalNode LEAST() { return getToken(PostgreSqlParser.LEAST, 0); } + public TerminalNode XMLCONCAT() { return getToken(PostgreSqlParser.XMLCONCAT, 0); } + public TerminalNode XMLELEMENT() { return getToken(PostgreSqlParser.XMLELEMENT, 0); } + public TerminalNode NAME_P() { return getToken(PostgreSqlParser.NAME_P, 0); } + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public Xml_attributesContext xml_attributes() { + return getRuleContext(Xml_attributesContext.class,0); + } + public TerminalNode XMLEXISTS() { return getToken(PostgreSqlParser.XMLEXISTS, 0); } + public C_exprContext c_expr() { + return getRuleContext(C_exprContext.class,0); + } + public Xmlexists_argumentContext xmlexists_argument() { + return getRuleContext(Xmlexists_argumentContext.class,0); + } + public TerminalNode XMLFOREST() { return getToken(PostgreSqlParser.XMLFOREST, 0); } + public Xml_attribute_listContext xml_attribute_list() { + return getRuleContext(Xml_attribute_listContext.class,0); + } + public TerminalNode XMLPARSE() { return getToken(PostgreSqlParser.XMLPARSE, 0); } + public Document_or_contentContext document_or_content() { + return getRuleContext(Document_or_contentContext.class,0); + } + public Xml_whitespace_optionContext xml_whitespace_option() { + return getRuleContext(Xml_whitespace_optionContext.class,0); + } + public TerminalNode XMLPI() { return getToken(PostgreSqlParser.XMLPI, 0); } + public TerminalNode XMLROOT() { return getToken(PostgreSqlParser.XMLROOT, 0); } + public TerminalNode XML_P() { return getToken(PostgreSqlParser.XML_P, 0); } + public Xml_root_versionContext xml_root_version() { + return getRuleContext(Xml_root_versionContext.class,0); + } + public Opt_xml_root_standaloneContext opt_xml_root_standalone() { + return getRuleContext(Opt_xml_root_standaloneContext.class,0); + } + public TerminalNode XMLSERIALIZE() { return getToken(PostgreSqlParser.XMLSERIALIZE, 0); } + public SimpletypenameContext simpletypename() { + return getRuleContext(SimpletypenameContext.class,0); + } + public Func_expr_common_subexprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_expr_common_subexpr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_expr_common_subexpr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_expr_common_subexpr(this); + } + } + + public final Func_expr_common_subexprContext func_expr_common_subexpr() throws RecognitionException { + Func_expr_common_subexprContext _localctx = new Func_expr_common_subexprContext(_ctx, getState()); + enterRule(_localctx, 1216, RULE_func_expr_common_subexpr); + int _la; + try { + setState(9286); + _errHandler.sync(this); + switch (_input.LA(1)) { + case COLLATION: + enterOuterAlt(_localctx, 1); + { + setState(9109); + match(COLLATION); + setState(9110); + match(FOR); + setState(9111); + match(OPEN_PAREN); + setState(9112); + a_expr(); + setState(9113); + match(CLOSE_PAREN); + } + break; + case CURRENT_DATE: + enterOuterAlt(_localctx, 2); + { + setState(9115); + match(CURRENT_DATE); + } + break; + case CURRENT_TIME: + enterOuterAlt(_localctx, 3); + { + setState(9116); + match(CURRENT_TIME); + setState(9121); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,583,_ctx) ) { + case 1: + { + setState(9117); + match(OPEN_PAREN); + setState(9118); + iconst(); + setState(9119); + match(CLOSE_PAREN); + } + break; + } + } + break; + case CURRENT_TIMESTAMP: + enterOuterAlt(_localctx, 4); + { + setState(9123); + match(CURRENT_TIMESTAMP); + setState(9128); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,584,_ctx) ) { + case 1: + { + setState(9124); + match(OPEN_PAREN); + setState(9125); + iconst(); + setState(9126); + match(CLOSE_PAREN); + } + break; + } + } + break; + case LOCALTIME: + enterOuterAlt(_localctx, 5); + { + setState(9130); + match(LOCALTIME); + setState(9135); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,585,_ctx) ) { + case 1: + { + setState(9131); + match(OPEN_PAREN); + setState(9132); + iconst(); + setState(9133); + match(CLOSE_PAREN); + } + break; + } + } + break; + case LOCALTIMESTAMP: + enterOuterAlt(_localctx, 6); + { + setState(9137); + match(LOCALTIMESTAMP); + setState(9142); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,586,_ctx) ) { + case 1: + { + setState(9138); + match(OPEN_PAREN); + setState(9139); + iconst(); + setState(9140); + match(CLOSE_PAREN); + } + break; + } + } + break; + case CURRENT_ROLE: + enterOuterAlt(_localctx, 7); + { + setState(9144); + match(CURRENT_ROLE); + } + break; + case CURRENT_USER: + enterOuterAlt(_localctx, 8); + { + setState(9145); + match(CURRENT_USER); + } + break; + case SESSION_USER: + enterOuterAlt(_localctx, 9); + { + setState(9146); + match(SESSION_USER); + } + break; + case USER: + enterOuterAlt(_localctx, 10); + { + setState(9147); + match(USER); + } + break; + case CURRENT_CATALOG: + enterOuterAlt(_localctx, 11); + { + setState(9148); + match(CURRENT_CATALOG); + } + break; + case CURRENT_SCHEMA: + enterOuterAlt(_localctx, 12); + { + setState(9149); + match(CURRENT_SCHEMA); + } + break; + case CAST: + enterOuterAlt(_localctx, 13); + { + setState(9150); + match(CAST); + setState(9151); + match(OPEN_PAREN); + setState(9152); + a_expr(); + setState(9153); + match(AS); + setState(9154); + typename(); + setState(9155); + match(CLOSE_PAREN); + } + break; + case EXTRACT: + enterOuterAlt(_localctx, 14); + { + setState(9157); + match(EXTRACT); + setState(9158); + match(OPEN_PAREN); + setState(9159); + extract_list(); + setState(9160); + match(CLOSE_PAREN); + } + break; + case NORMALIZE: + enterOuterAlt(_localctx, 15); + { + setState(9162); + match(NORMALIZE); + setState(9163); + match(OPEN_PAREN); + setState(9164); + a_expr(); + setState(9167); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(9165); + match(COMMA); + setState(9166); + unicode_normal_form(); + } + } + + setState(9169); + match(CLOSE_PAREN); + } + break; + case OVERLAY: + enterOuterAlt(_localctx, 16); + { + setState(9171); + match(OVERLAY); + setState(9172); + match(OPEN_PAREN); + setState(9173); + overlay_list(); + setState(9174); + match(CLOSE_PAREN); + } + break; + case POSITION: + enterOuterAlt(_localctx, 17); + { + setState(9176); + match(POSITION); + setState(9177); + match(OPEN_PAREN); + setState(9178); + position_list(); + setState(9179); + match(CLOSE_PAREN); + } + break; + case SUBSTRING: + enterOuterAlt(_localctx, 18); + { + setState(9181); + match(SUBSTRING); + setState(9182); + match(OPEN_PAREN); + setState(9183); + substr_list(); + setState(9184); + match(CLOSE_PAREN); + } + break; + case TREAT: + enterOuterAlt(_localctx, 19); + { + setState(9186); + match(TREAT); + setState(9187); + match(OPEN_PAREN); + setState(9188); + a_expr(); + setState(9189); + match(AS); + setState(9190); + typename(); + setState(9191); + match(CLOSE_PAREN); + } + break; + case TRIM: + enterOuterAlt(_localctx, 20); + { + setState(9193); + match(TRIM); + setState(9194); + match(OPEN_PAREN); + setState(9196); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 41)) & ~0x3f) == 0 && ((1L << (_la - 41)) & 72057611217797121L) != 0)) { + { + setState(9195); + _la = _input.LA(1); + if ( !(((((_la - 41)) & ~0x3f) == 0 && ((1L << (_la - 41)) & 72057611217797121L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(9198); + trim_list(); + setState(9199); + match(CLOSE_PAREN); + } + break; + case NULLIF: + enterOuterAlt(_localctx, 21); + { + setState(9201); + match(NULLIF); + setState(9202); + match(OPEN_PAREN); + setState(9203); + a_expr(); + setState(9204); + match(COMMA); + setState(9205); + a_expr(); + setState(9206); + match(CLOSE_PAREN); + } + break; + case COALESCE: + enterOuterAlt(_localctx, 22); + { + setState(9208); + match(COALESCE); + setState(9209); + match(OPEN_PAREN); + setState(9210); + expr_list(); + setState(9211); + match(CLOSE_PAREN); + } + break; + case GREATEST: + enterOuterAlt(_localctx, 23); + { + setState(9213); + match(GREATEST); + setState(9214); + match(OPEN_PAREN); + setState(9215); + expr_list(); + setState(9216); + match(CLOSE_PAREN); + } + break; + case LEAST: + enterOuterAlt(_localctx, 24); + { + setState(9218); + match(LEAST); + setState(9219); + match(OPEN_PAREN); + setState(9220); + expr_list(); + setState(9221); + match(CLOSE_PAREN); + } + break; + case XMLCONCAT: + enterOuterAlt(_localctx, 25); + { + setState(9223); + match(XMLCONCAT); + setState(9224); + match(OPEN_PAREN); + setState(9225); + expr_list(); + setState(9226); + match(CLOSE_PAREN); + } + break; + case XMLELEMENT: + enterOuterAlt(_localctx, 26); + { + setState(9228); + match(XMLELEMENT); + setState(9229); + match(OPEN_PAREN); + setState(9230); + match(NAME_P); + setState(9231); + collabel(); + setState(9237); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(9232); + match(COMMA); + setState(9235); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,589,_ctx) ) { + case 1: + { + setState(9233); + xml_attributes(); + } + break; + case 2: + { + setState(9234); + expr_list(); + } + break; + } + } + } + + setState(9239); + match(CLOSE_PAREN); + } + break; + case XMLEXISTS: + enterOuterAlt(_localctx, 27); + { + setState(9241); + match(XMLEXISTS); + setState(9242); + match(OPEN_PAREN); + setState(9243); + c_expr(); + setState(9244); + xmlexists_argument(); + setState(9245); + match(CLOSE_PAREN); + } + break; + case XMLFOREST: + enterOuterAlt(_localctx, 28); + { + setState(9247); + match(XMLFOREST); + setState(9248); + match(OPEN_PAREN); + setState(9249); + xml_attribute_list(); + setState(9250); + match(CLOSE_PAREN); + } + break; + case XMLPARSE: + enterOuterAlt(_localctx, 29); + { + setState(9252); + match(XMLPARSE); + setState(9253); + match(OPEN_PAREN); + setState(9254); + document_or_content(); + setState(9255); + a_expr(); + setState(9256); + xml_whitespace_option(); + setState(9257); + match(CLOSE_PAREN); + } + break; + case XMLPI: + enterOuterAlt(_localctx, 30); + { + setState(9259); + match(XMLPI); + setState(9260); + match(OPEN_PAREN); + setState(9261); + match(NAME_P); + setState(9262); + collabel(); + setState(9265); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(9263); + match(COMMA); + setState(9264); + a_expr(); + } + } + + setState(9267); + match(CLOSE_PAREN); + } + break; + case XMLROOT: + enterOuterAlt(_localctx, 31); + { + setState(9269); + match(XMLROOT); + setState(9270); + match(OPEN_PAREN); + setState(9271); + match(XML_P); + setState(9272); + a_expr(); + setState(9273); + match(COMMA); + setState(9274); + xml_root_version(); + setState(9275); + opt_xml_root_standalone(); + setState(9276); + match(CLOSE_PAREN); + } + break; + case XMLSERIALIZE: + enterOuterAlt(_localctx, 32); + { + setState(9278); + match(XMLSERIALIZE); + setState(9279); + match(OPEN_PAREN); + setState(9280); + document_or_content(); + setState(9281); + a_expr(); + setState(9282); + match(AS); + setState(9283); + simpletypename(); + setState(9284); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xml_root_versionContext extends ParserRuleContext { + public TerminalNode VERSION_P() { return getToken(PostgreSqlParser.VERSION_P, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode VALUE_P() { return getToken(PostgreSqlParser.VALUE_P, 0); } + public Xml_root_versionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xml_root_version; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXml_root_version(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXml_root_version(this); + } + } + + public final Xml_root_versionContext xml_root_version() throws RecognitionException { + Xml_root_versionContext _localctx = new Xml_root_versionContext(_ctx, getState()); + enterRule(_localctx, 1218, RULE_xml_root_version); + try { + setState(9293); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,593,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9288); + match(VERSION_P); + setState(9289); + a_expr(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9290); + match(VERSION_P); + setState(9291); + match(NO); + setState(9292); + match(VALUE_P); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_xml_root_standaloneContext extends ParserRuleContext { + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public TerminalNode STANDALONE_P() { return getToken(PostgreSqlParser.STANDALONE_P, 0); } + public TerminalNode YES_P() { return getToken(PostgreSqlParser.YES_P, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode VALUE_P() { return getToken(PostgreSqlParser.VALUE_P, 0); } + public Opt_xml_root_standaloneContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_xml_root_standalone; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_xml_root_standalone(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_xml_root_standalone(this); + } + } + + public final Opt_xml_root_standaloneContext opt_xml_root_standalone() throws RecognitionException { + Opt_xml_root_standaloneContext _localctx = new Opt_xml_root_standaloneContext(_ctx, getState()); + enterRule(_localctx, 1220, RULE_opt_xml_root_standalone); + try { + setState(9306); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,594,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9295); + match(COMMA); + setState(9296); + match(STANDALONE_P); + setState(9297); + match(YES_P); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9298); + match(COMMA); + setState(9299); + match(STANDALONE_P); + setState(9300); + match(NO); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9301); + match(COMMA); + setState(9302); + match(STANDALONE_P); + setState(9303); + match(NO); + setState(9304); + match(VALUE_P); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xml_attributesContext extends ParserRuleContext { + public TerminalNode XMLATTRIBUTES() { return getToken(PostgreSqlParser.XMLATTRIBUTES, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Xml_attribute_listContext xml_attribute_list() { + return getRuleContext(Xml_attribute_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Xml_attributesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xml_attributes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXml_attributes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXml_attributes(this); + } + } + + public final Xml_attributesContext xml_attributes() throws RecognitionException { + Xml_attributesContext _localctx = new Xml_attributesContext(_ctx, getState()); + enterRule(_localctx, 1222, RULE_xml_attributes); + try { + enterOuterAlt(_localctx, 1); + { + setState(9308); + match(XMLATTRIBUTES); + setState(9309); + match(OPEN_PAREN); + setState(9310); + xml_attribute_list(); + setState(9311); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xml_attribute_listContext extends ParserRuleContext { + public List xml_attribute_el() { + return getRuleContexts(Xml_attribute_elContext.class); + } + public Xml_attribute_elContext xml_attribute_el(int i) { + return getRuleContext(Xml_attribute_elContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Xml_attribute_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xml_attribute_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXml_attribute_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXml_attribute_list(this); + } + } + + public final Xml_attribute_listContext xml_attribute_list() throws RecognitionException { + Xml_attribute_listContext _localctx = new Xml_attribute_listContext(_ctx, getState()); + enterRule(_localctx, 1224, RULE_xml_attribute_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9313); + xml_attribute_el(); + setState(9318); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(9314); + match(COMMA); + setState(9315); + xml_attribute_el(); + } + } + setState(9320); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xml_attribute_elContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public Xml_attribute_elContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xml_attribute_el; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXml_attribute_el(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXml_attribute_el(this); + } + } + + public final Xml_attribute_elContext xml_attribute_el() throws RecognitionException { + Xml_attribute_elContext _localctx = new Xml_attribute_elContext(_ctx, getState()); + enterRule(_localctx, 1226, RULE_xml_attribute_el); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9321); + a_expr(); + setState(9324); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(9322); + match(AS); + setState(9323); + collabel(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Document_or_contentContext extends ParserRuleContext { + public TerminalNode DOCUMENT_P() { return getToken(PostgreSqlParser.DOCUMENT_P, 0); } + public TerminalNode CONTENT_P() { return getToken(PostgreSqlParser.CONTENT_P, 0); } + public Document_or_contentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_document_or_content; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDocument_or_content(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDocument_or_content(this); + } + } + + public final Document_or_contentContext document_or_content() throws RecognitionException { + Document_or_contentContext _localctx = new Document_or_contentContext(_ctx, getState()); + enterRule(_localctx, 1228, RULE_document_or_content); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9326); + _la = _input.LA(1); + if ( !(_la==CONTENT_P || _la==DOCUMENT_P) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xml_whitespace_optionContext extends ParserRuleContext { + public TerminalNode PRESERVE() { return getToken(PostgreSqlParser.PRESERVE, 0); } + public TerminalNode WHITESPACE_P() { return getToken(PostgreSqlParser.WHITESPACE_P, 0); } + public TerminalNode STRIP_P() { return getToken(PostgreSqlParser.STRIP_P, 0); } + public Xml_whitespace_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xml_whitespace_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXml_whitespace_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXml_whitespace_option(this); + } + } + + public final Xml_whitespace_optionContext xml_whitespace_option() throws RecognitionException { + Xml_whitespace_optionContext _localctx = new Xml_whitespace_optionContext(_ctx, getState()); + enterRule(_localctx, 1230, RULE_xml_whitespace_option); + try { + setState(9333); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PRESERVE: + enterOuterAlt(_localctx, 1); + { + setState(9328); + match(PRESERVE); + setState(9329); + match(WHITESPACE_P); + } + break; + case STRIP_P: + enterOuterAlt(_localctx, 2); + { + setState(9330); + match(STRIP_P); + setState(9331); + match(WHITESPACE_P); + } + break; + case CLOSE_PAREN: + enterOuterAlt(_localctx, 3); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xmlexists_argumentContext extends ParserRuleContext { + public TerminalNode PASSING() { return getToken(PostgreSqlParser.PASSING, 0); } + public C_exprContext c_expr() { + return getRuleContext(C_exprContext.class,0); + } + public List xml_passing_mech() { + return getRuleContexts(Xml_passing_mechContext.class); + } + public Xml_passing_mechContext xml_passing_mech(int i) { + return getRuleContext(Xml_passing_mechContext.class,i); + } + public Xmlexists_argumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xmlexists_argument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXmlexists_argument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXmlexists_argument(this); + } + } + + public final Xmlexists_argumentContext xmlexists_argument() throws RecognitionException { + Xmlexists_argumentContext _localctx = new Xmlexists_argumentContext(_ctx, getState()); + enterRule(_localctx, 1232, RULE_xmlexists_argument); + try { + setState(9350); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,598,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9335); + match(PASSING); + setState(9336); + c_expr(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9337); + match(PASSING); + setState(9338); + c_expr(); + setState(9339); + xml_passing_mech(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9341); + match(PASSING); + setState(9342); + xml_passing_mech(); + setState(9343); + c_expr(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9345); + match(PASSING); + setState(9346); + xml_passing_mech(); + setState(9347); + c_expr(); + setState(9348); + xml_passing_mech(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Xml_passing_mechContext extends ParserRuleContext { + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public TerminalNode REF() { return getToken(PostgreSqlParser.REF, 0); } + public TerminalNode VALUE_P() { return getToken(PostgreSqlParser.VALUE_P, 0); } + public Xml_passing_mechContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xml_passing_mech; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXml_passing_mech(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXml_passing_mech(this); + } + } + + public final Xml_passing_mechContext xml_passing_mech() throws RecognitionException { + Xml_passing_mechContext _localctx = new Xml_passing_mechContext(_ctx, getState()); + enterRule(_localctx, 1234, RULE_xml_passing_mech); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9352); + match(BY); + setState(9353); + _la = _input.LA(1); + if ( !(_la==REF || _la==VALUE_P) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Within_group_clauseContext extends ParserRuleContext { + public TerminalNode WITHIN() { return getToken(PostgreSqlParser.WITHIN, 0); } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Sort_clauseContext sort_clause() { + return getRuleContext(Sort_clauseContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Within_group_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_within_group_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWithin_group_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWithin_group_clause(this); + } + } + + public final Within_group_clauseContext within_group_clause() throws RecognitionException { + Within_group_clauseContext _localctx = new Within_group_clauseContext(_ctx, getState()); + enterRule(_localctx, 1236, RULE_within_group_clause); + try { + setState(9362); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,599,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9355); + match(WITHIN); + setState(9356); + match(GROUP_P); + setState(9357); + match(OPEN_PAREN); + setState(9358); + sort_clause(); + setState(9359); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Filter_clauseContext extends ParserRuleContext { + public TerminalNode FILTER() { return getToken(PostgreSqlParser.FILTER, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Filter_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_filter_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFilter_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFilter_clause(this); + } + } + + public final Filter_clauseContext filter_clause() throws RecognitionException { + Filter_clauseContext _localctx = new Filter_clauseContext(_ctx, getState()); + enterRule(_localctx, 1238, RULE_filter_clause); + try { + setState(9371); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,600,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9364); + match(FILTER); + setState(9365); + match(OPEN_PAREN); + setState(9366); + match(WHERE); + setState(9367); + a_expr(); + setState(9368); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Window_clauseContext extends ParserRuleContext { + public TerminalNode WINDOW() { return getToken(PostgreSqlParser.WINDOW, 0); } + public Window_definition_listContext window_definition_list() { + return getRuleContext(Window_definition_listContext.class,0); + } + public Window_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_window_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWindow_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWindow_clause(this); + } + } + + public final Window_clauseContext window_clause() throws RecognitionException { + Window_clauseContext _localctx = new Window_clauseContext(_ctx, getState()); + enterRule(_localctx, 1240, RULE_window_clause); + try { + setState(9376); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WINDOW: + enterOuterAlt(_localctx, 1); + { + setState(9373); + match(WINDOW); + setState(9374); + window_definition_list(); + } + break; + case EOF: + case OPEN_PAREN: + case CLOSE_PAREN: + case COMMA: + case SEMI: + case ANALYSE: + case ANALYZE: + case CREATE: + case DO: + case EXCEPT: + case FETCH: + case FOR: + case GRANT: + case INTERSECT: + case INTO: + case LIMIT: + case OFFSET: + case ON: + case ORDER: + case RETURNING: + case SELECT: + case TABLE: + case THEN: + case UNION: + case USING: + case WHEN: + case WITH: + case ABORT_P: + case ALTER: + case BEGIN_P: + case CHECKPOINT: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMIT: + case COPY: + case DEALLOCATE: + case DECLARE: + case DELETE_P: + case DISCARD: + case DROP: + case EXECUTE: + case EXPLAIN: + case INSERT: + case LISTEN: + case LOAD: + case LOCK_P: + case MERGE: + case MOVE: + case NOTIFY: + case PREPARE: + case REASSIGN: + case REFRESH: + case REINDEX: + case RELEASE: + case RESET: + case REVOKE: + case ROLLBACK: + case SAVEPOINT: + case SECURITY: + case SET: + case SHOW: + case START: + case TRUNCATE: + case UNLISTEN: + case UPDATE: + case VACUUM: + case VALUES: + case CALL: + case IMPORT_P: + case END_P: + case LOOP: + case MetaCommand: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + @SuppressWarnings("CheckReturnValue") public static class Window_definition_listContext extends ParserRuleContext { public List window_definition() { @@ -36836,30 +78040,30 @@ public class PostgreSqlParser extends Parser { public final Window_definition_listContext window_definition_list() throws RecognitionException { Window_definition_listContext _localctx = new Window_definition_listContext(_ctx, getState()); - enterRule(_localctx, 408, RULE_window_definition_list); + enterRule(_localctx, 1242, RULE_window_definition_list); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(4461); + setState(9378); window_definition(); - setState(4466); + setState(9383); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,521,_ctx); + _alt = getInterpreter().adaptivePredict(_input,602,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(4462); + setState(9379); match(COMMA); - setState(4463); + setState(9380); window_definition(); } } } - setState(4468); + setState(9385); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,521,_ctx); + _alt = getInterpreter().adaptivePredict(_input,602,_ctx); } } } @@ -36876,8 +78080,8 @@ public class PostgreSqlParser extends Parser { @SuppressWarnings("CheckReturnValue") public static class Window_definitionContext extends ParserRuleContext { - public Window_nameContext window_name() { - return getRuleContext(Window_nameContext.class,0); + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); } public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } public Window_specificationContext window_specification() { @@ -36899,15 +78103,15 @@ public class PostgreSqlParser extends Parser { public final Window_definitionContext window_definition() throws RecognitionException { Window_definitionContext _localctx = new Window_definitionContext(_ctx, getState()); - enterRule(_localctx, 410, RULE_window_definition); + enterRule(_localctx, 1244, RULE_window_definition); try { enterOuterAlt(_localctx, 1); { - setState(4469); - window_name(); - setState(4470); + setState(9386); + colid(); + setState(9387); match(AS); - setState(4471); + setState(9388); window_specification(); } } @@ -36922,221 +78126,14 @@ public class PostgreSqlParser extends Parser { return _localctx; } - @SuppressWarnings("CheckReturnValue") - public static class Window_clauseContext extends ParserRuleContext { - public TerminalNode WINDOW() { return getToken(PostgreSqlParser.WINDOW, 0); } - public Window_definition_listContext window_definition_list() { - return getRuleContext(Window_definition_listContext.class,0); - } - public Window_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_window_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWindow_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWindow_clause(this); - } - } - - public final Window_clauseContext window_clause() throws RecognitionException { - Window_clauseContext _localctx = new Window_clauseContext(_ctx, getState()); - enterRule(_localctx, 412, RULE_window_clause); - try { - enterOuterAlt(_localctx, 1); - { - setState(4473); - match(WINDOW); - setState(4474); - window_definition_list(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Window_specificationContext extends ParserRuleContext { - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Window_nameContext window_name() { - return getRuleContext(Window_nameContext.class,0); - } - public Partition_clauseContext partition_clause() { - return getRuleContext(Partition_clauseContext.class,0); - } - public Order_by_clauseContext order_by_clause() { - return getRuleContext(Order_by_clauseContext.class,0); - } - public Frame_clauseContext frame_clause() { - return getRuleContext(Frame_clauseContext.class,0); - } - public Window_specificationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_window_specification; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWindow_specification(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWindow_specification(this); - } - } - - public final Window_specificationContext window_specification() throws RecognitionException { - Window_specificationContext _localctx = new Window_specificationContext(_ctx, getState()); - enterRule(_localctx, 414, RULE_window_specification); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4476); - match(OPEN_PAREN); - setState(4478); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,522,_ctx) ) { - case 1: - { - setState(4477); - window_name(); - } - break; - } - setState(4481); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PARTITION) { - { - setState(4480); - partition_clause(); - } - } - - setState(4484); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ORDER) { - { - setState(4483); - order_by_clause(); - } - } - - setState(4487); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==RANGE || _la==ROWS) { - { - setState(4486); - frame_clause(); - } - } - - setState(4489); - match(CLOSE_PAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Partition_clauseContext extends ParserRuleContext { - public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Partition_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_partition_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPartition_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPartition_clause(this); - } - } - - public final Partition_clauseContext partition_clause() throws RecognitionException { - Partition_clauseContext _localctx = new Partition_clauseContext(_ctx, getState()); - enterRule(_localctx, 416, RULE_partition_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4491); - match(PARTITION); - setState(4492); - match(BY); - setState(4493); - expr(0); - setState(4498); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4494); - match(COMMA); - setState(4495); - expr(0); - } - } - setState(4500); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - @SuppressWarnings("CheckReturnValue") public static class Over_clauseContext extends ParserRuleContext { public TerminalNode OVER() { return getToken(PostgreSqlParser.OVER, 0); } public Window_specificationContext window_specification() { return getRuleContext(Window_specificationContext.class,0); } - public Window_nameContext window_name() { - return getRuleContext(Window_nameContext.class,0); + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); } public Over_clauseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -37154,2022 +78151,556 @@ public class PostgreSqlParser extends Parser { public final Over_clauseContext over_clause() throws RecognitionException { Over_clauseContext _localctx = new Over_clauseContext(_ctx, getState()); - enterRule(_localctx, 418, RULE_over_clause); + enterRule(_localctx, 1246, RULE_over_clause); try { - enterOuterAlt(_localctx, 1); - { - setState(4501); - match(OVER); - setState(4504); + setState(9396); _errHandler.sync(this); - switch (_input.LA(1)) { - case OPEN_PAREN: - { - setState(4502); - window_specification(); - } - break; - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(4503); - window_name(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Combine_clauseContext extends ParserRuleContext { - public TerminalNode UNION() { return getToken(PostgreSqlParser.UNION, 0); } - public TerminalNode INTERSECT() { return getToken(PostgreSqlParser.INTERSECT, 0); } - public TerminalNode EXCEPT() { return getToken(PostgreSqlParser.EXCEPT, 0); } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); - } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public Combine_clauseContext combine_clause() { - return getRuleContext(Combine_clauseContext.class,0); - } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } - public Combine_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_combine_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCombine_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCombine_clause(this); - } - } - - public final Combine_clauseContext combine_clause() throws RecognitionException { - Combine_clauseContext _localctx = new Combine_clauseContext(_ctx, getState()); - enterRule(_localctx, 420, RULE_combine_clause); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(4506); - _la = _input.LA(1); - if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4508); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ALL || _la==DISTINCT) { - { - setState(4507); - _la = _input.LA(1); - if ( !(_la==ALL || _la==DISTINCT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(4513); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,529,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(4510); - match(OPEN_PAREN); - } - } - } - setState(4515); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,529,_ctx); - } - setState(4518); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,530,_ctx) ) { - case 1: - { - setState(4516); - select_stmt(); - } - break; - case 2: - { - setState(4517); - values_stmt(); - } - break; - } - setState(4523); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,531,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(4520); - match(CLOSE_PAREN); - } - } - } - setState(4525); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,531,_ctx); - } - setState(4527); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,532,_ctx) ) { - case 1: - { - setState(4526); - combine_clause(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Order_by_clauseContext extends ParserRuleContext { - public TerminalNode ORDER() { return getToken(PostgreSqlParser.ORDER, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public List order_by_item() { - return getRuleContexts(Order_by_itemContext.class); - } - public Order_by_itemContext order_by_item(int i) { - return getRuleContext(Order_by_itemContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Order_by_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_order_by_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOrder_by_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOrder_by_clause(this); - } - } - - public final Order_by_clauseContext order_by_clause() throws RecognitionException { - Order_by_clauseContext _localctx = new Order_by_clauseContext(_ctx, getState()); - enterRule(_localctx, 422, RULE_order_by_clause); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(4529); - match(ORDER); - setState(4530); - match(BY); - setState(4531); - order_by_item(); - setState(4536); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,533,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(4532); - match(COMMA); - setState(4533); - order_by_item(); - } - } - } - setState(4538); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,533,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Order_by_itemContext extends ParserRuleContext { - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public TerminalNode DOUBLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.DOUBLEQ_STRING_LITERAL, 0); } - public TerminalNode ASC() { return getToken(PostgreSqlParser.ASC, 0); } - public TerminalNode DESC() { return getToken(PostgreSqlParser.DESC, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public List NULLS() { return getTokens(PostgreSqlParser.NULLS); } - public TerminalNode NULLS(int i) { - return getToken(PostgreSqlParser.NULLS, i); - } - public List FIRST() { return getTokens(PostgreSqlParser.FIRST); } - public TerminalNode FIRST(int i) { - return getToken(PostgreSqlParser.FIRST, i); - } - public List LAST() { return getTokens(PostgreSqlParser.LAST); } - public TerminalNode LAST(int i) { - return getToken(PostgreSqlParser.LAST, i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Order_by_itemContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_order_by_item; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOrder_by_item(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOrder_by_item(this); - } - } - - public final Order_by_itemContext order_by_item() throws RecognitionException { - Order_by_itemContext _localctx = new Order_by_itemContext(_ctx, getState()); - enterRule(_localctx, 424, RULE_order_by_item); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(4541); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,534,_ctx) ) { - case 1: - { - setState(4539); - expr(0); - } - break; - case 2: - { - setState(4540); - match(DOUBLEQ_STRING_LITERAL); - } - break; - } - setState(4547); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,535,_ctx) ) { - case 1: - { - setState(4543); - match(ASC); - } - break; - case 2: - { - setState(4544); - match(DESC); - } - break; - case 3: - { - setState(4545); - match(USING); - setState(4546); - expr(0); - } - break; - } - setState(4560); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,537,_ctx) ) { - case 1: - { - { - setState(4549); - match(NULLS); - setState(4550); - _la = _input.LA(1); - if ( !(_la==FIRST || _la==LAST) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - setState(4557); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,536,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(4552); - match(COMMA); - { - setState(4553); - match(NULLS); - setState(4554); - _la = _input.LA(1); - if ( !(_la==FIRST || _la==LAST) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - } - } - setState(4559); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,536,_ctx); - } - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Limit_clauseContext extends ParserRuleContext { - public TerminalNode LIMIT() { return getToken(PostgreSqlParser.LIMIT, 0); } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral() { - return getRuleContext(ParameterOrIntegerLiteralContext.class,0); - } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public Func_callContext func_call() { - return getRuleContext(Func_callContext.class,0); - } - public Limit_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_limit_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLimit_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLimit_clause(this); - } - } - - public final Limit_clauseContext limit_clause() throws RecognitionException { - Limit_clauseContext _localctx = new Limit_clauseContext(_ctx, getState()); - enterRule(_localctx, 426, RULE_limit_clause); - try { - enterOuterAlt(_localctx, 1); - { - setState(4562); - match(LIMIT); - setState(4566); - _errHandler.sync(this); - switch (_input.LA(1)) { - case COLON: - case INTEGER_LITERAL: - case QMARK: - { - setState(4563); - parameterOrIntegerLiteral(); - } - break; - case ALL: - { - setState(4564); - match(ALL); - } - break; - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(4565); - func_call(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Offset_clauseContext extends ParserRuleContext { - public TerminalNode OFFSET() { return getToken(PostgreSqlParser.OFFSET, 0); } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral() { - return getRuleContext(ParameterOrIntegerLiteralContext.class,0); - } - public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } - public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } - public Offset_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_offset_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOffset_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOffset_clause(this); - } - } - - public final Offset_clauseContext offset_clause() throws RecognitionException { - Offset_clauseContext _localctx = new Offset_clauseContext(_ctx, getState()); - enterRule(_localctx, 428, RULE_offset_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4568); - match(OFFSET); - setState(4569); - parameterOrIntegerLiteral(); - setState(4571); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,539,_ctx) ) { - case 1: - { - setState(4570); - _la = _input.LA(1); - if ( !(_la==ROW || _la==ROWS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Fetch_clauseContext extends ParserRuleContext { - public TerminalNode FETCH() { return getToken(PostgreSqlParser.FETCH, 0); } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode FIRST() { return getToken(PostgreSqlParser.FIRST, 0); } - public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } - public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } - public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral() { - return getRuleContext(ParameterOrIntegerLiteralContext.class,0); - } - public Fetch_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fetch_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFetch_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFetch_clause(this); - } - } - - public final Fetch_clauseContext fetch_clause() throws RecognitionException { - Fetch_clauseContext _localctx = new Fetch_clauseContext(_ctx, getState()); - enterRule(_localctx, 430, RULE_fetch_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4573); - match(FETCH); - setState(4574); - _la = _input.LA(1); - if ( !(_la==FIRST || _la==NEXT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4576); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 763)) & ~0x3f) == 0 && ((1L << (_la - 763)) & 576460752303427585L) != 0)) { - { - setState(4575); - parameterOrIntegerLiteral(); - } - } - - setState(4578); - _la = _input.LA(1); - if ( !(_la==ROW || _la==ROWS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4579); - match(ONLY); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class For_clauseContext extends ParserRuleContext { - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } - public TerminalNode KEY() { return getToken(PostgreSqlParser.KEY, 0); } - public TerminalNode SHARE() { return getToken(PostgreSqlParser.SHARE, 0); } - public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } - public List table_name_() { - return getRuleContexts(Table_name_Context.class); - } - public Table_name_Context table_name_(int i) { - return getRuleContext(Table_name_Context.class,i); - } - public List NOWAIT() { return getTokens(PostgreSqlParser.NOWAIT); } - public TerminalNode NOWAIT(int i) { - return getToken(PostgreSqlParser.NOWAIT, i); - } - public List SKIP_() { return getTokens(PostgreSqlParser.SKIP_); } - public TerminalNode SKIP_(int i) { - return getToken(PostgreSqlParser.SKIP_, i); - } - public List LOCKED() { return getTokens(PostgreSqlParser.LOCKED); } - public TerminalNode LOCKED(int i) { - return getToken(PostgreSqlParser.LOCKED, i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public For_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_for_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFor_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFor_clause(this); - } - } - - public final For_clauseContext for_clause() throws RecognitionException { - For_clauseContext _localctx = new For_clauseContext(_ctx, getState()); - enterRule(_localctx, 432, RULE_for_clause); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(4581); - match(FOR); - setState(4589); - _errHandler.sync(this); - switch (_input.LA(1)) { - case UPDATE: - { - setState(4582); - match(UPDATE); - } - break; - case NO: - { - setState(4583); - match(NO); - setState(4584); - match(KEY); - setState(4585); - match(UPDATE); - } - break; - case SHARE: - { - setState(4586); - match(SHARE); - } - break; - case KEY: - { - setState(4587); - match(KEY); - setState(4588); - match(SHARE); - } - break; - default: - throw new NoViableAltException(this); - } - setState(4600); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,543,_ctx) ) { - case 1: - { - setState(4591); - match(OF); - setState(4592); - table_name_(); - setState(4597); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,542,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(4593); - match(COMMA); - setState(4594); - table_name_(); - } - } - } - setState(4599); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,542,_ctx); - } - } - break; - } - setState(4607); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,545,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(4605); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NOWAIT: - { - setState(4602); - match(NOWAIT); - } - break; - case SKIP_: - { - setState(4603); - match(SKIP_); - setState(4604); - match(LOCKED); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(4609); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,545,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Updater_clauseContext extends ParserRuleContext { - public List updater_expr() { - return getRuleContexts(Updater_exprContext.class); - } - public Updater_exprContext updater_expr(int i) { - return getRuleContext(Updater_exprContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Updater_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_updater_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUpdater_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUpdater_clause(this); - } - } - - public final Updater_clauseContext updater_clause() throws RecognitionException { - Updater_clauseContext _localctx = new Updater_clauseContext(_ctx, getState()); - enterRule(_localctx, 434, RULE_updater_clause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4610); - updater_expr(); - setState(4615); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4611); - match(COMMA); - setState(4612); - updater_expr(); - } - } - setState(4617); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Updater_exprContext extends ParserRuleContext { - public ExprContext expr() { - return getRuleContext(ExprContext.class,0); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } - public Expr_listContext expr_list() { - return getRuleContext(Expr_listContext.class,0); - } - public Updater_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_updater_expr; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUpdater_expr(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUpdater_expr(this); - } - } - - public final Updater_exprContext updater_expr() throws RecognitionException { - Updater_exprContext _localctx = new Updater_exprContext(_ctx, getState()); - enterRule(_localctx, 436, RULE_updater_expr); - try { - setState(4627); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,548,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,604,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(4618); - expr(0); + setState(9390); + match(OVER); + setState(9393); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + { + setState(9391); + window_specification(); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(9392); + colid(); + } + break; + default: + throw new NoViableAltException(this); + } } break; case 2: enterOuterAlt(_localctx, 2); { - { - setState(4619); - match(OPEN_PAREN); - setState(4620); - name_list(); - setState(4621); - match(CLOSE_PAREN); - setState(4622); - match(EQUAL); - setState(4625); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,547,_ctx) ) { - case 1: - { - setState(4623); - expr(0); - } - break; - case 2: - { - setState(4624); - expr_list(); - } - break; - } - } } break; } @@ -39186,35 +78717,53 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Returning_clauseContext extends ParserRuleContext { - public TerminalNode RETURNING() { return getToken(PostgreSqlParser.RETURNING, 0); } - public Column_listContext column_list() { - return getRuleContext(Column_listContext.class,0); + public static class Window_specificationContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Opt_existing_window_nameContext opt_existing_window_name() { + return getRuleContext(Opt_existing_window_nameContext.class,0); } - public Returning_clauseContext(ParserRuleContext parent, int invokingState) { + public Opt_partition_clauseContext opt_partition_clause() { + return getRuleContext(Opt_partition_clauseContext.class,0); + } + public Opt_sort_clauseContext opt_sort_clause() { + return getRuleContext(Opt_sort_clauseContext.class,0); + } + public Opt_frame_clauseContext opt_frame_clause() { + return getRuleContext(Opt_frame_clauseContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Window_specificationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_returning_clause; } + @Override public int getRuleIndex() { return RULE_window_specification; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterReturning_clause(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWindow_specification(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitReturning_clause(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWindow_specification(this); } } - public final Returning_clauseContext returning_clause() throws RecognitionException { - Returning_clauseContext _localctx = new Returning_clauseContext(_ctx, getState()); - enterRule(_localctx, 438, RULE_returning_clause); + public final Window_specificationContext window_specification() throws RecognitionException { + Window_specificationContext _localctx = new Window_specificationContext(_ctx, getState()); + enterRule(_localctx, 1248, RULE_window_specification); try { enterOuterAlt(_localctx, 1); { - setState(4629); - match(RETURNING); - setState(4630); - column_list(); + setState(9398); + match(OPEN_PAREN); + setState(9399); + opt_existing_window_name(); + setState(9400); + opt_partition_clause(); + setState(9401); + opt_sort_clause(); + setState(9402); + opt_frame_clause(); + setState(9403); + match(CLOSE_PAREN); } } catch (RecognitionException re) { @@ -39229,1539 +78778,106 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class ExprContext extends ParserRuleContext { - public Token op; - public TerminalNode NULL() { return getToken(PostgreSqlParser.NULL, 0); } - public TerminalNode CURRENT_DATE() { return getToken(PostgreSqlParser.CURRENT_DATE, 0); } - public TerminalNode CURRENT_ROLE() { return getToken(PostgreSqlParser.CURRENT_ROLE, 0); } - public TerminalNode CURRENT_TIME() { return getToken(PostgreSqlParser.CURRENT_TIME, 0); } - public TerminalNode CURRENT_TIMESTAMP() { return getToken(PostgreSqlParser.CURRENT_TIMESTAMP, 0); } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public TerminalNode HEX_INTEGER_LITERAL() { return getToken(PostgreSqlParser.HEX_INTEGER_LITERAL, 0); } - public TerminalNode NUMERIC_LITERAL() { return getToken(PostgreSqlParser.NUMERIC_LITERAL, 0); } - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public TerminalNode BIT_STRING() { return getToken(PostgreSqlParser.BIT_STRING, 0); } - public TerminalNode REGEX_STRING() { return getToken(PostgreSqlParser.REGEX_STRING, 0); } - public List DOLLAR_DOLLAR() { return getTokens(PostgreSqlParser.DOLLAR_DOLLAR); } - public TerminalNode DOLLAR_DOLLAR(int i) { - return getToken(PostgreSqlParser.DOLLAR_DOLLAR, i); + public static class Opt_existing_window_nameContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); } - public List DOLLAR() { return getTokens(PostgreSqlParser.DOLLAR); } - public TerminalNode DOLLAR(int i) { - return getToken(PostgreSqlParser.DOLLAR, i); - } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public Bool_exprContext bool_expr() { - return getRuleContext(Bool_exprContext.class,0); - } - public Values_stmtContext values_stmt() { - return getRuleContext(Values_stmtContext.class,0); - } - public Expr_listContext expr_list() { - return getRuleContext(Expr_listContext.class,0); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Type_nameContext type_name() { - return getRuleContext(Type_nameContext.class,0); - } - public TerminalNode BANG_BANG() { return getToken(PostgreSqlParser.BANG_BANG, 0); } - public TerminalNode AT_SIGN() { return getToken(PostgreSqlParser.AT_SIGN, 0); } - public TerminalNode PLUS() { return getToken(PostgreSqlParser.PLUS, 0); } - public TerminalNode MINUS() { return getToken(PostgreSqlParser.MINUS, 0); } - public TerminalNode TIL() { return getToken(PostgreSqlParser.TIL, 0); } - public TerminalNode QMARK_HYPHEN() { return getToken(PostgreSqlParser.QMARK_HYPHEN, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public Func_callContext func_call() { - return getRuleContext(Func_callContext.class,0); - } - public Over_clauseContext over_clause() { - return getRuleContext(Over_clauseContext.class,0); - } - public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public List data_type() { - return getRuleContexts(Data_typeContext.class); - } - public Data_typeContext data_type(int i) { - return getRuleContext(Data_typeContext.class,i); - } - public Correlation_nameContext correlation_name() { - return getRuleContext(Correlation_nameContext.class,0); - } - public TerminalNode DOT() { return getToken(PostgreSqlParser.DOT, 0); } - public Column_nameContext column_name() { - return getRuleContext(Column_nameContext.class,0); - } - public Case_exprContext case_expr() { - return getRuleContext(Case_exprContext.class,0); - } - public AggregateContext aggregate() { - return getRuleContext(AggregateContext.class,0); - } - public Array_cons_exprContext array_cons_expr() { - return getRuleContext(Array_cons_exprContext.class,0); - } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } - public TerminalNode DOLLAR_DEC() { return getToken(PostgreSqlParser.DOLLAR_DEC, 0); } - public Select_stmtContext select_stmt() { - return getRuleContext(Select_stmtContext.class,0); - } - public ParameterContext parameter() { - return getRuleContext(ParameterContext.class,0); - } - public TerminalNode CARET() { return getToken(PostgreSqlParser.CARET, 0); } - public TerminalNode PIPE_SLASH() { return getToken(PostgreSqlParser.PIPE_SLASH, 0); } - public TerminalNode PIPE_PIPE_SLASH() { return getToken(PostgreSqlParser.PIPE_PIPE_SLASH, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public TerminalNode SLASH() { return getToken(PostgreSqlParser.SLASH, 0); } - public TerminalNode PERCENT() { return getToken(PostgreSqlParser.PERCENT, 0); } - public TerminalNode AMP() { return getToken(PostgreSqlParser.AMP, 0); } - public TerminalNode PIPE() { return getToken(PostgreSqlParser.PIPE, 0); } - public TerminalNode HASH() { return getToken(PostgreSqlParser.HASH, 0); } - public TerminalNode LT_LT() { return getToken(PostgreSqlParser.LT_LT, 0); } - public TerminalNode LT_LT_EQ() { return getToken(PostgreSqlParser.LT_LT_EQ, 0); } - public TerminalNode GT_GT() { return getToken(PostgreSqlParser.GT_GT, 0); } - public TerminalNode AT_AT() { return getToken(PostgreSqlParser.AT_AT, 0); } - public TerminalNode LT_HYPHEN_GT() { return getToken(PostgreSqlParser.LT_HYPHEN_GT, 0); } - public TerminalNode AT_GT() { return getToken(PostgreSqlParser.AT_GT, 0); } - public TerminalNode LT_AT() { return getToken(PostgreSqlParser.LT_AT, 0); } - public TerminalNode TIL_EQ() { return getToken(PostgreSqlParser.TIL_EQ, 0); } - public TerminalNode TIL_STAR() { return getToken(PostgreSqlParser.TIL_STAR, 0); } - public TerminalNode TIL_TIL() { return getToken(PostgreSqlParser.TIL_TIL, 0); } - public TerminalNode TIL_LT_TIL() { return getToken(PostgreSqlParser.TIL_LT_TIL, 0); } - public TerminalNode TIL_GT_TIL() { return getToken(PostgreSqlParser.TIL_GT_TIL, 0); } - public TerminalNode TIL_LTE_TIL() { return getToken(PostgreSqlParser.TIL_LTE_TIL, 0); } - public TerminalNode TIL_GTE_TIL() { return getToken(PostgreSqlParser.TIL_GTE_TIL, 0); } - public TerminalNode LT_QMARK_GT() { return getToken(PostgreSqlParser.LT_QMARK_GT, 0); } - public TerminalNode HYPHEN_GT() { return getToken(PostgreSqlParser.HYPHEN_GT, 0); } - public TerminalNode HYPHEN_GT_GT() { return getToken(PostgreSqlParser.HYPHEN_GT_GT, 0); } - public TerminalNode HASH_HASH() { return getToken(PostgreSqlParser.HASH_HASH, 0); } - public TerminalNode HASH_GT() { return getToken(PostgreSqlParser.HASH_GT, 0); } - public TerminalNode HASH_GT_GT() { return getToken(PostgreSqlParser.HASH_GT_GT, 0); } - public TerminalNode QMARK() { return getToken(PostgreSqlParser.QMARK, 0); } - public TerminalNode QMARK_PIPE() { return getToken(PostgreSqlParser.QMARK_PIPE, 0); } - public TerminalNode QMARK_AMP() { return getToken(PostgreSqlParser.QMARK_AMP, 0); } - public TerminalNode QMARK_HASH() { return getToken(PostgreSqlParser.QMARK_HASH, 0); } - public TerminalNode LT_CARET() { return getToken(PostgreSqlParser.LT_CARET, 0); } - public TerminalNode AMP_LT() { return getToken(PostgreSqlParser.AMP_LT, 0); } - public TerminalNode HYPHEN_PIPE_HYPHEN() { return getToken(PostgreSqlParser.HYPHEN_PIPE_HYPHEN, 0); } - public TerminalNode HASH_EQ() { return getToken(PostgreSqlParser.HASH_EQ, 0); } - public TerminalNode AMP_AMP() { return getToken(PostgreSqlParser.AMP_AMP, 0); } - public TerminalNode PIPE_PIPE() { return getToken(PostgreSqlParser.PIPE_PIPE, 0); } - public TerminalNode EQUAL_GT() { return getToken(PostgreSqlParser.EQUAL_GT, 0); } - public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } - public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } - public TerminalNode LIKE() { return getToken(PostgreSqlParser.LIKE, 0); } - public TerminalNode BETWEEN() { return getToken(PostgreSqlParser.BETWEEN, 0); } - public TerminalNode IN() { return getToken(PostgreSqlParser.IN, 0); } - public TerminalNode LT() { return getToken(PostgreSqlParser.LT, 0); } - public TerminalNode GT() { return getToken(PostgreSqlParser.GT, 0); } - public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } - public TerminalNode LTE() { return getToken(PostgreSqlParser.LTE, 0); } - public TerminalNode GTE() { return getToken(PostgreSqlParser.GTE, 0); } - public TerminalNode LT_GT() { return getToken(PostgreSqlParser.LT_GT, 0); } - public TerminalNode BANG_EQUAL() { return getToken(PostgreSqlParser.BANG_EQUAL, 0); } - public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } - public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public List OPEN_BRACKET() { return getTokens(PostgreSqlParser.OPEN_BRACKET); } - public TerminalNode OPEN_BRACKET(int i) { - return getToken(PostgreSqlParser.OPEN_BRACKET, i); - } - public List CLOSE_BRACKET() { return getTokens(PostgreSqlParser.CLOSE_BRACKET); } - public TerminalNode CLOSE_BRACKET(int i) { - return getToken(PostgreSqlParser.CLOSE_BRACKET, i); - } - public TerminalNode BANG() { return getToken(PostgreSqlParser.BANG, 0); } - public List COLON() { return getTokens(PostgreSqlParser.COLON); } - public TerminalNode COLON(int i) { - return getToken(PostgreSqlParser.COLON, i); - } - public List COLON_COLON() { return getTokens(PostgreSqlParser.COLON_COLON); } - public TerminalNode COLON_COLON(int i) { - return getToken(PostgreSqlParser.COLON_COLON, i); - } - public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } - public TerminalNode AT() { return getToken(PostgreSqlParser.AT, 0); } - public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } - public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } - public ExprContext(ParserRuleContext parent, int invokingState) { + public Opt_existing_window_nameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_expr; } + @Override public int getRuleIndex() { return RULE_opt_existing_window_name; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExpr(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_existing_window_name(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExpr(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_existing_window_name(this); } } - public final ExprContext expr() throws RecognitionException { - return expr(0); - } - - private ExprContext expr(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - ExprContext _localctx = new ExprContext(_ctx, _parentState); - ExprContext _prevctx = _localctx; - int _startState = 440; - enterRecursionRule(_localctx, 440, RULE_expr, _p); - int _la; + public final Opt_existing_window_nameContext opt_existing_window_name() throws RecognitionException { + Opt_existing_window_nameContext _localctx = new Opt_existing_window_nameContext(_ctx, getState()); + enterRule(_localctx, 1250, RULE_opt_existing_window_name); try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(4710); + setState(9407); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,552,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,605,_ctx) ) { case 1: + enterOuterAlt(_localctx, 1); { - setState(4633); - match(NULL); + setState(9405); + colid(); } break; case 2: + enterOuterAlt(_localctx, 2); { - setState(4634); - match(CURRENT_DATE); } break; - case 3: + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_partition_clauseContext extends ParserRuleContext { + public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Opt_partition_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_partition_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_partition_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_partition_clause(this); + } + } + + public final Opt_partition_clauseContext opt_partition_clause() throws RecognitionException { + Opt_partition_clauseContext _localctx = new Opt_partition_clauseContext(_ctx, getState()); + enterRule(_localctx, 1252, RULE_opt_partition_clause); + try { + setState(9413); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PARTITION: + enterOuterAlt(_localctx, 1); { - setState(4635); - match(CURRENT_ROLE); - } - break; - case 4: - { - setState(4636); - match(CURRENT_TIME); - } - break; - case 5: - { - setState(4637); - match(CURRENT_TIMESTAMP); - } - break; - case 6: - { - setState(4638); - match(CURRENT_USER); - } - break; - case 7: - { - setState(4639); - match(DEFAULT); - } - break; - case 8: - { - setState(4640); - match(INTEGER_LITERAL); - } - break; - case 9: - { - setState(4641); - match(HEX_INTEGER_LITERAL); - } - break; - case 10: - { - setState(4642); - match(NUMERIC_LITERAL); - } - break; - case 11: - { - setState(4643); - match(SINGLEQ_STRING_LITERAL); - } - break; - case 12: - { - setState(4644); - match(BIT_STRING); - } - break; - case 13: - { - setState(4645); - match(REGEX_STRING); - } - break; - case 14: - { - setState(4646); - match(DOLLAR_DOLLAR); - setState(4648); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(4647); - _la = _input.LA(1); - if ( _la <= 0 || (_la==DOLLAR) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(4650); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,549,_ctx); - } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); - setState(4652); - match(DOLLAR_DOLLAR); - } - break; - case 15: - { - setState(4653); - match(DOLLAR); - setState(4654); - identifier(0); - setState(4656); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(4655); - _la = _input.LA(1); - if ( _la <= 0 || (_la==DOLLAR) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - setState(4658); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -1L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & -1L) != 0) || ((((_la - 192)) & ~0x3f) == 0 && ((1L << (_la - 192)) & -1L) != 0) || ((((_la - 256)) & ~0x3f) == 0 && ((1L << (_la - 256)) & -1L) != 0) || ((((_la - 320)) & ~0x3f) == 0 && ((1L << (_la - 320)) & -1L) != 0) || ((((_la - 384)) & ~0x3f) == 0 && ((1L << (_la - 384)) & -1L) != 0) || ((((_la - 448)) & ~0x3f) == 0 && ((1L << (_la - 448)) & -1L) != 0) || ((((_la - 512)) & ~0x3f) == 0 && ((1L << (_la - 512)) & -1L) != 0) || ((((_la - 576)) & ~0x3f) == 0 && ((1L << (_la - 576)) & -1L) != 0) || ((((_la - 640)) & ~0x3f) == 0 && ((1L << (_la - 640)) & -1L) != 0) || ((((_la - 704)) & ~0x3f) == 0 && ((1L << (_la - 704)) & -2305843009213693953L) != 0) || ((((_la - 768)) & ~0x3f) == 0 && ((1L << (_la - 768)) & -1L) != 0) || ((((_la - 832)) & ~0x3f) == 0 && ((1L << (_la - 832)) & 63L) != 0) ); - setState(4660); - match(DOLLAR); - setState(4661); - identifier(0); - setState(4662); - match(DOLLAR); - } - break; - case 16: - { - setState(4664); - bool_expr(0); - } - break; - case 17: - { - setState(4665); - values_stmt(); - } - break; - case 18: - { - setState(4666); + setState(9409); + match(PARTITION); + setState(9410); + match(BY); + setState(9411); expr_list(); } break; - case 19: + case CLOSE_PAREN: + case ORDER: + case RANGE: + case ROWS: + case GROUPS: + enterOuterAlt(_localctx, 2); { - setState(4667); - match(OPEN_PAREN); - setState(4668); - expr(0); - setState(4669); - match(CLOSE_PAREN); } break; - case 20: - { - setState(4671); - type_name(); - setState(4672); - match(SINGLEQ_STRING_LITERAL); - } - break; - case 21: - { - setState(4674); - ((ExprContext)_localctx).op = _input.LT(1); - _la = _input.LA(1); - if ( !(((((_la - 788)) & ~0x3f) == 0 && ((1L << (_la - 788)) & 8724152325L) != 0)) ) { - ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4675); - expr(31); - } - break; - case 22: - { - setState(4676); - ((ExprContext)_localctx).op = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==QMARK_HYPHEN || _la==TIL) ) { - ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4677); - expr(30); - } - break; - case 23: - { - setState(4678); - ((ExprContext)_localctx).op = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==ALL || _la==NOT) ) { - ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4679); - expr(18); - } - break; - case 24: - { - setState(4680); - func_call(); - setState(4682); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,551,_ctx) ) { - case 1: - { - setState(4681); - over_clause(); - } - break; - } - } - break; - case 25: - { - setState(4684); - identifier(0); - } - break; - case 26: - { - setState(4685); - match(CAST); - setState(4686); - match(OPEN_PAREN); - setState(4687); - expr(0); - setState(4688); - match(AS); - setState(4689); - data_type(); - setState(4690); - match(CLOSE_PAREN); - } - break; - case 27: - { - setState(4692); - correlation_name(); - setState(4693); - match(DOT); - setState(4694); - column_name(); - } - break; - case 28: - { - setState(4696); - case_expr(); - } - break; - case 29: - { - setState(4697); - data_type(); - setState(4698); - expr(10); - } - break; - case 30: - { - setState(4700); - aggregate(); - } - break; - case 31: - { - setState(4701); - array_cons_expr(); - } - break; - case 32: - { - setState(4702); - match(EXISTS); - setState(4703); - expr(4); - } - break; - case 33: - { - setState(4704); - match(DOLLAR_DEC); - } - break; - case 34: - { - setState(4705); - match(OPEN_PAREN); - setState(4706); - select_stmt(); - setState(4707); - match(CLOSE_PAREN); - } - break; - case 35: - { - setState(4709); - parameter(); - } - break; - } - _ctx.stop = _input.LT(-1); - setState(4815); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,564,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - if ( _parseListeners!=null ) triggerExitRuleEvent(); - _prevctx = _localctx; - { - setState(4813); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,563,_ctx) ) { - case 1: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4712); - if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)"); - setState(4713); - ((ExprContext)_localctx).op = _input.LT(1); - _la = _input.LA(1); - if ( !(((((_la - 792)) & ~0x3f) == 0 && ((1L << (_la - 792)) & 402653185L) != 0)) ) { - ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4714); - expr(29); - } - break; - case 2: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4715); - if (!(precpred(_ctx, 27))) throw new FailedPredicateException(this, "precpred(_ctx, 27)"); - setState(4716); - ((ExprContext)_localctx).op = _input.LT(1); - _la = _input.LA(1); - if ( !(((((_la - 767)) & ~0x3f) == 0 && ((1L << (_la - 767)) & 1153484454560268289L) != 0)) ) { - ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4717); - expr(28); - } - break; - case 3: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4718); - if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)"); - setState(4719); - ((ExprContext)_localctx).op = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==MINUS || _la==PLUS) ) { - ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4720); - expr(27); - } - break; - case 4: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4721); - if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)"); - setState(4722); - ((ExprContext)_localctx).op = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==AND || _la==NOT || _la==OR || ((((_la - 783)) & ~0x3f) == 0 && ((1L << (_la - 783)) & 8984714941548575L) != 0)) ) { - ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4723); - expr(26); - } - break; - case 5: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4724); - if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)"); - setState(4728); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NOT: - { - setState(4725); - match(NOT); - setState(4726); - match(LIKE); - } - break; - case LIKE: - { - setState(4727); - match(LIKE); - } - break; - default: - throw new NoViableAltException(this); - } - setState(4730); - expr(25); - } - break; - case 6: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4731); - if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)"); - setState(4733); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOT) { - { - setState(4732); - match(NOT); - } - } - - setState(4735); - match(BETWEEN); - setState(4736); - expr(0); - setState(4737); - match(AND); - setState(4738); - expr(24); - } - break; - case 7: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4740); - if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); - setState(4744); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NOT: - { - setState(4741); - match(NOT); - setState(4742); - match(IN); - } - break; - case IN: - { - setState(4743); - match(IN); - } - break; - default: - throw new NoViableAltException(this); - } - setState(4746); - expr(23); - } - break; - case 8: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4747); - if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)"); - setState(4748); - ((ExprContext)_localctx).op = _input.LT(1); - _la = _input.LA(1); - if ( !(((((_la - 791)) & ~0x3f) == 0 && ((1L << (_la - 791)) & 622645L) != 0)) ) { - ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(4749); - expr(22); - } - break; - case 9: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4750); - if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); - setState(4751); - match(IS); - setState(4753); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOT) { - { - setState(4752); - match(NOT); - } - } - - setState(4755); - match(DISTINCT); - setState(4756); - match(FROM); - setState(4757); - expr(20); - } - break; - case 10: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4758); - if (!(precpred(_ctx, 34))) throw new FailedPredicateException(this, "precpred(_ctx, 34)"); - setState(4759); - match(OPEN_BRACKET); - setState(4760); - expr(0); - setState(4761); - match(CLOSE_BRACKET); - } - break; - case 11: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4763); - if (!(precpred(_ctx, 29))) throw new FailedPredicateException(this, "precpred(_ctx, 29)"); - setState(4764); - ((ExprContext)_localctx).op = match(BANG); - } - break; - case 12: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4765); - if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); - setState(4766); - ((ExprContext)_localctx).op = match(IS); - setState(4771); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,557,_ctx) ) { - case 1: - { - setState(4767); - bool_expr(0); - } - break; - case 2: - { - setState(4768); - match(NULL); - } - break; - case 3: - { - setState(4769); - match(NOT); - setState(4770); - match(NULL); - } - break; - } - } - break; - case 13: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4773); - if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); - setState(4783); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(4774); - match(OPEN_BRACKET); - setState(4776); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,558,_ctx) ) { - case 1: - { - setState(4775); - expr(0); - } - break; - } - setState(4778); - match(COLON); - setState(4780); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -11575800568512526L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334777102337L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245452583049L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206567384408260611L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & -6102417216219643909L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 4537576733544546303L) != 0) || ((((_la - 788)) & ~0x3f) == 0 && ((1L << (_la - 788)) & 1262854602757L) != 0)) { - { - setState(4779); - expr(0); - } - } - - setState(4782); - match(CLOSE_BRACKET); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(4785); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,560,_ctx); - } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); - } - break; - case 14: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4787); - if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); - setState(4790); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(4788); - match(COLON_COLON); - setState(4789); - data_type(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(4792); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,561,_ctx); - } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); - } - break; - case 15: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4794); - if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); - setState(4795); - match(IS); - setState(4796); - match(OF); - setState(4797); - match(OPEN_PAREN); - setState(4798); - data_type(); - setState(4799); - match(CLOSE_PAREN); - } - break; - case 16: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4801); - if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); - setState(4802); - match(DOT); - setState(4805); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(4803); - identifier(0); - } - break; - case STAR: - { - setState(4804); - match(STAR); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 17: - { - _localctx = new ExprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_expr); - setState(4807); - if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); - { - setState(4808); - match(AT); - setState(4809); - match(TIME); - setState(4810); - match(ZONE); - } - setState(4812); - match(SINGLEQ_STRING_LITERAL); - } - break; - } - } - } - setState(4817); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,564,_ctx); - } + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -40770,345 +78886,326 @@ public class PostgreSqlParser extends Parser { _errHandler.recover(this, re); } finally { - unrollRecursionContexts(_parentctx); + exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") - public static class ParameterContext extends ParserRuleContext { - public Token prefix; - public TerminalNode COLON() { return getToken(PostgreSqlParser.COLON, 0); } - public TerminalNode SPEL() { return getToken(PostgreSqlParser.SPEL, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public static class Opt_frame_clauseContext extends ParserRuleContext { + public TerminalNode RANGE() { return getToken(PostgreSqlParser.RANGE, 0); } + public Frame_extentContext frame_extent() { + return getRuleContext(Frame_extentContext.class,0); } - public Reserved_keywordContext reserved_keyword() { - return getRuleContext(Reserved_keywordContext.class,0); + public Opt_window_exclusion_clauseContext opt_window_exclusion_clause() { + return getRuleContext(Opt_window_exclusion_clauseContext.class,0); } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public TerminalNode QMARK() { return getToken(PostgreSqlParser.QMARK, 0); } - public ParameterContext(ParserRuleContext parent, int invokingState) { + public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } + public TerminalNode GROUPS() { return getToken(PostgreSqlParser.GROUPS, 0); } + public Opt_frame_clauseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_parameter; } + @Override public int getRuleIndex() { return RULE_opt_frame_clause; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterParameter(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_frame_clause(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitParameter(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_frame_clause(this); } } - public final ParameterContext parameter() throws RecognitionException { - ParameterContext _localctx = new ParameterContext(_ctx, getState()); - enterRule(_localctx, 442, RULE_parameter); + public final Opt_frame_clauseContext opt_frame_clause() throws RecognitionException { + Opt_frame_clauseContext _localctx = new Opt_frame_clauseContext(_ctx, getState()); + enterRule(_localctx, 1254, RULE_opt_frame_clause); try { - setState(4832); + setState(9428); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,566,_ctx) ) { + switch (_input.LA(1)) { + case RANGE: + enterOuterAlt(_localctx, 1); + { + setState(9415); + match(RANGE); + setState(9416); + frame_extent(); + setState(9417); + opt_window_exclusion_clause(); + } + break; + case ROWS: + enterOuterAlt(_localctx, 2); + { + setState(9419); + match(ROWS); + setState(9420); + frame_extent(); + setState(9421); + opt_window_exclusion_clause(); + } + break; + case GROUPS: + enterOuterAlt(_localctx, 3); + { + setState(9423); + match(GROUPS); + setState(9424); + frame_extent(); + setState(9425); + opt_window_exclusion_clause(); + } + break; + case CLOSE_PAREN: + enterOuterAlt(_localctx, 4); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Frame_extentContext extends ParserRuleContext { + public List frame_bound() { + return getRuleContexts(Frame_boundContext.class); + } + public Frame_boundContext frame_bound(int i) { + return getRuleContext(Frame_boundContext.class,i); + } + public TerminalNode BETWEEN() { return getToken(PostgreSqlParser.BETWEEN, 0); } + public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } + public Frame_extentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frame_extent; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrame_extent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrame_extent(this); + } + } + + public final Frame_extentContext frame_extent() throws RecognitionException { + Frame_extentContext _localctx = new Frame_extentContext(_ctx, getState()); + enterRule(_localctx, 1256, RULE_frame_extent); + try { + setState(9436); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,608,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(4818); - match(COLON); - setState(4819); - match(SPEL); + setState(9430); + frame_bound(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(4820); - match(COLON); - setState(4821); - identifier(0); + setState(9431); + match(BETWEEN); + setState(9432); + frame_bound(); + setState(9433); + match(AND); + setState(9434); + frame_bound(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Frame_boundContext extends ParserRuleContext { + public TerminalNode UNBOUNDED() { return getToken(PostgreSqlParser.UNBOUNDED, 0); } + public TerminalNode PRECEDING() { return getToken(PostgreSqlParser.PRECEDING, 0); } + public TerminalNode FOLLOWING() { return getToken(PostgreSqlParser.FOLLOWING, 0); } + public TerminalNode CURRENT_P() { return getToken(PostgreSqlParser.CURRENT_P, 0); } + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Frame_boundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frame_bound; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrame_bound(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrame_bound(this); + } + } + + public final Frame_boundContext frame_bound() throws RecognitionException { + Frame_boundContext _localctx = new Frame_boundContext(_ctx, getState()); + enterRule(_localctx, 1258, RULE_frame_bound); + int _la; + try { + setState(9445); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,609,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9438); + match(UNBOUNDED); + setState(9439); + _la = _input.LA(1); + if ( !(_la==FOLLOWING || _la==PRECEDING) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9440); + match(CURRENT_P); + setState(9441); + match(ROW); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(4822); - match(COLON); - setState(4823); - reserved_keyword(); + setState(9442); + a_expr(); + setState(9443); + _la = _input.LA(1); + if ( !(_la==FOLLOWING || _la==PRECEDING) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } } break; - case 4: - enterOuterAlt(_localctx, 4); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_window_exclusion_clauseContext extends ParserRuleContext { + public TerminalNode EXCLUDE() { return getToken(PostgreSqlParser.EXCLUDE, 0); } + public TerminalNode CURRENT_P() { return getToken(PostgreSqlParser.CURRENT_P, 0); } + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public TerminalNode TIES() { return getToken(PostgreSqlParser.TIES, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode OTHERS() { return getToken(PostgreSqlParser.OTHERS, 0); } + public Opt_window_exclusion_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_window_exclusion_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_window_exclusion_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_window_exclusion_clause(this); + } + } + + public final Opt_window_exclusion_clauseContext opt_window_exclusion_clause() throws RecognitionException { + Opt_window_exclusion_clauseContext _localctx = new Opt_window_exclusion_clauseContext(_ctx, getState()); + enterRule(_localctx, 1260, RULE_opt_window_exclusion_clause); + try { + setState(9457); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EXCLUDE: + enterOuterAlt(_localctx, 1); { - setState(4824); - match(COLON); - setState(4825); - match(INTEGER_LITERAL); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(4826); - ((ParameterContext)_localctx).prefix = match(QMARK); - setState(4827); - match(SPEL); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(4828); - ((ParameterContext)_localctx).prefix = match(QMARK); - setState(4830); + setState(9447); + match(EXCLUDE); + setState(9454); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,565,_ctx) ) { - case 1: + switch (_input.LA(1)) { + case CURRENT_P: { - setState(4829); - match(INTEGER_LITERAL); + setState(9448); + match(CURRENT_P); + setState(9449); + match(ROW); } break; - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class ParameterOrIntegerLiteralContext extends ParserRuleContext { - public ParameterContext parameter() { - return getRuleContext(ParameterContext.class,0); - } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public ParameterOrIntegerLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameterOrIntegerLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterParameterOrIntegerLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitParameterOrIntegerLiteral(this); - } - } - - public final ParameterOrIntegerLiteralContext parameterOrIntegerLiteral() throws RecognitionException { - ParameterOrIntegerLiteralContext _localctx = new ParameterOrIntegerLiteralContext(_ctx, getState()); - enterRule(_localctx, 444, RULE_parameterOrIntegerLiteral); - try { - setState(4836); - _errHandler.sync(this); - switch (_input.LA(1)) { - case COLON: - case QMARK: - enterOuterAlt(_localctx, 1); - { - setState(4834); - parameter(); - } - break; - case INTEGER_LITERAL: - enterOuterAlt(_localctx, 2); - { - setState(4835); - match(INTEGER_LITERAL); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class ParameterOrNumericLiteralContext extends ParserRuleContext { - public ParameterContext parameter() { - return getRuleContext(ParameterContext.class,0); - } - public TerminalNode NUMERIC_LITERAL() { return getToken(PostgreSqlParser.NUMERIC_LITERAL, 0); } - public ParameterOrNumericLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameterOrNumericLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterParameterOrNumericLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitParameterOrNumericLiteral(this); - } - } - - public final ParameterOrNumericLiteralContext parameterOrNumericLiteral() throws RecognitionException { - ParameterOrNumericLiteralContext _localctx = new ParameterOrNumericLiteralContext(_ctx, getState()); - enterRule(_localctx, 446, RULE_parameterOrNumericLiteral); - try { - setState(4840); - _errHandler.sync(this); - switch (_input.LA(1)) { - case COLON: - case QMARK: - enterOuterAlt(_localctx, 1); - { - setState(4838); - parameter(); - } - break; - case NUMERIC_LITERAL: - enterOuterAlt(_localctx, 2); - { - setState(4839); - match(NUMERIC_LITERAL); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Bool_exprContext extends ParserRuleContext { - public TerminalNode TRUE() { return getToken(PostgreSqlParser.TRUE, 0); } - public TerminalNode FALSE() { return getToken(PostgreSqlParser.FALSE, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public List bool_expr() { - return getRuleContexts(Bool_exprContext.class); - } - public Bool_exprContext bool_expr(int i) { - return getRuleContext(Bool_exprContext.class,i); - } - public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } - public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } - public Bool_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_bool_expr; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterBool_expr(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitBool_expr(this); - } - } - - public final Bool_exprContext bool_expr() throws RecognitionException { - return bool_expr(0); - } - - private Bool_exprContext bool_expr(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - Bool_exprContext _localctx = new Bool_exprContext(_ctx, _parentState); - Bool_exprContext _prevctx = _localctx; - int _startState = 448; - enterRecursionRule(_localctx, 448, RULE_bool_expr, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(4847); - _errHandler.sync(this); - switch (_input.LA(1)) { - case TRUE: - { - setState(4843); - match(TRUE); - } - break; - case FALSE: - { - setState(4844); - match(FALSE); - } - break; - case NOT: - { - setState(4845); - match(NOT); - setState(4846); - bool_expr(3); - } - break; - default: - throw new NoViableAltException(this); - } - _ctx.stop = _input.LT(-1); - setState(4857); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,571,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - if ( _parseListeners!=null ) triggerExitRuleEvent(); - _prevctx = _localctx; + case GROUP_P: { - setState(4855); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,570,_ctx) ) { - case 1: - { - _localctx = new Bool_exprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_bool_expr); - setState(4849); - if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(4850); - match(AND); - setState(4851); - bool_expr(3); - } - break; - case 2: - { - _localctx = new Bool_exprContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_bool_expr); - setState(4852); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(4853); - match(OR); - setState(4854); - bool_expr(2); - } - break; + setState(9450); + match(GROUP_P); } - } + break; + case TIES: + { + setState(9451); + match(TIES); + } + break; + case NO: + { + setState(9452); + match(NO); + setState(9453); + match(OTHERS); + } + break; + default: + throw new NoViableAltException(this); } - setState(4859); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,571,_ctx); - } + } + break; + case CLOSE_PAREN: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -41117,140 +79214,611 @@ public class PostgreSqlParser extends Parser { _errHandler.recover(this, re); } finally { - unrollRecursionContexts(_parentctx); + exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") - public static class Case_exprContext extends ParserRuleContext { - public TerminalNode CASE() { return getToken(PostgreSqlParser.CASE, 0); } - public List expr() { - return getRuleContexts(ExprContext.class); + public static class RowContext extends ParserRuleContext { + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); } - public TerminalNode END() { return getToken(PostgreSqlParser.END, 0); } - public List WHEN() { return getTokens(PostgreSqlParser.WHEN); } - public TerminalNode WHEN(int i) { - return getToken(PostgreSqlParser.WHEN, i); - } - public List THEN() { return getTokens(PostgreSqlParser.THEN); } - public TerminalNode THEN(int i) { - return getToken(PostgreSqlParser.THEN, i); - } - public TerminalNode ELSE() { return getToken(PostgreSqlParser.ELSE, 0); } - public List predicate() { - return getRuleContexts(PredicateContext.class); - } - public PredicateContext predicate(int i) { - return getRuleContext(PredicateContext.class,i); - } - public Case_exprContext(ParserRuleContext parent, int invokingState) { + public RowContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_case_expr; } + @Override public int getRuleIndex() { return RULE_row; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCase_expr(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRow(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCase_expr(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRow(this); } } - public final Case_exprContext case_expr() throws RecognitionException { - Case_exprContext _localctx = new Case_exprContext(_ctx, getState()); - enterRule(_localctx, 450, RULE_case_expr); + public final RowContext row() throws RecognitionException { + RowContext _localctx = new RowContext(_ctx, getState()); + enterRule(_localctx, 1262, RULE_row); int _la; try { - setState(4893); + setState(9471); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,576,_ctx) ) { + switch (_input.LA(1)) { + case ROW: + enterOuterAlt(_localctx, 1); + { + setState(9459); + match(ROW); + setState(9460); + match(OPEN_PAREN); + setState(9462); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -3963470962275334648L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & -2120073201L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & -1L) != 0) || ((((_la - 205)) & ~0x3f) == 0 && ((1L << (_la - 205)) & -1266637395197953L) != 0) || ((((_la - 269)) & ~0x3f) == 0 && ((1L << (_la - 269)) & -1L) != 0) || ((((_la - 333)) & ~0x3f) == 0 && ((1L << (_la - 333)) & -1L) != 0) || ((((_la - 397)) & ~0x3f) == 0 && ((1L << (_la - 397)) & -576460752303423489L) != 0) || ((((_la - 461)) & ~0x3f) == 0 && ((1L << (_la - 461)) & -5764695483964456961L) != 0) || ((((_la - 525)) & ~0x3f) == 0 && ((1L << (_la - 525)) & -1L) != 0) || ((((_la - 589)) & ~0x3f) == 0 && ((1L << (_la - 589)) & -6300535878691323905L) != 0) || ((((_la - 653)) & ~0x3f) == 0 && ((1L << (_la - 653)) & 1051921L) != 0)) { + { + setState(9461); + expr_list(); + } + } + + setState(9464); + match(CLOSE_PAREN); + } + break; + case OPEN_PAREN: + enterOuterAlt(_localctx, 2); + { + setState(9465); + match(OPEN_PAREN); + setState(9466); + expr_list(); + setState(9467); + match(COMMA); + setState(9468); + a_expr(); + setState(9469); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Explicit_rowContext extends ParserRuleContext { + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Explicit_rowContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicit_row; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplicit_row(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplicit_row(this); + } + } + + public final Explicit_rowContext explicit_row() throws RecognitionException { + Explicit_rowContext _localctx = new Explicit_rowContext(_ctx, getState()); + enterRule(_localctx, 1264, RULE_explicit_row); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9473); + match(ROW); + setState(9474); + match(OPEN_PAREN); + setState(9476); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -3963470962275334648L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & -2120073201L) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & -1L) != 0) || ((((_la - 205)) & ~0x3f) == 0 && ((1L << (_la - 205)) & -1266637395197953L) != 0) || ((((_la - 269)) & ~0x3f) == 0 && ((1L << (_la - 269)) & -1L) != 0) || ((((_la - 333)) & ~0x3f) == 0 && ((1L << (_la - 333)) & -1L) != 0) || ((((_la - 397)) & ~0x3f) == 0 && ((1L << (_la - 397)) & -576460752303423489L) != 0) || ((((_la - 461)) & ~0x3f) == 0 && ((1L << (_la - 461)) & -5764695483964456961L) != 0) || ((((_la - 525)) & ~0x3f) == 0 && ((1L << (_la - 525)) & -1L) != 0) || ((((_la - 589)) & ~0x3f) == 0 && ((1L << (_la - 589)) & -6300535878691323905L) != 0) || ((((_la - 653)) & ~0x3f) == 0 && ((1L << (_la - 653)) & 1051921L) != 0)) { + { + setState(9475); + expr_list(); + } + } + + setState(9478); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Implicit_rowContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Implicit_rowContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_implicit_row; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterImplicit_row(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitImplicit_row(this); + } + } + + public final Implicit_rowContext implicit_row() throws RecognitionException { + Implicit_rowContext _localctx = new Implicit_rowContext(_ctx, getState()); + enterRule(_localctx, 1266, RULE_implicit_row); + try { + enterOuterAlt(_localctx, 1); + { + setState(9480); + match(OPEN_PAREN); + setState(9481); + expr_list(); + setState(9482); + match(COMMA); + setState(9483); + a_expr(); + setState(9484); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Sub_typeContext extends ParserRuleContext { + public TerminalNode ANY() { return getToken(PostgreSqlParser.ANY, 0); } + public TerminalNode SOME() { return getToken(PostgreSqlParser.SOME, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public Sub_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sub_type; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSub_type(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSub_type(this); + } + } + + public final Sub_typeContext sub_type() throws RecognitionException { + Sub_typeContext _localctx = new Sub_typeContext(_ctx, getState()); + enterRule(_localctx, 1268, RULE_sub_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9486); + _la = _input.LA(1); + if ( !(((((_la - 32)) & ~0x3f) == 0 && ((1L << (_la - 32)) & 1152921504606846993L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class All_opContext extends ParserRuleContext { + public TerminalNode Operator() { return getToken(PostgreSqlParser.Operator, 0); } + public MathopContext mathop() { + return getRuleContext(MathopContext.class,0); + } + public All_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_all_op; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAll_op(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAll_op(this); + } + } + + public final All_opContext all_op() throws RecognitionException { + All_opContext _localctx = new All_opContext(_ctx, getState()); + enterRule(_localctx, 1270, RULE_all_op); + try { + setState(9490); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Operator: + enterOuterAlt(_localctx, 1); + { + setState(9488); + match(Operator); + } + break; + case STAR: + case EQUAL: + case PLUS: + case MINUS: + case SLASH: + case CARET: + case LT: + case GT: + case LESS_EQUALS: + case GREATER_EQUALS: + case NOT_EQUALS: + case PERCENT: + enterOuterAlt(_localctx, 2); + { + setState(9489); + mathop(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MathopContext extends ParserRuleContext { + public TerminalNode PLUS() { return getToken(PostgreSqlParser.PLUS, 0); } + public TerminalNode MINUS() { return getToken(PostgreSqlParser.MINUS, 0); } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public TerminalNode SLASH() { return getToken(PostgreSqlParser.SLASH, 0); } + public TerminalNode PERCENT() { return getToken(PostgreSqlParser.PERCENT, 0); } + public TerminalNode CARET() { return getToken(PostgreSqlParser.CARET, 0); } + public TerminalNode LT() { return getToken(PostgreSqlParser.LT, 0); } + public TerminalNode GT() { return getToken(PostgreSqlParser.GT, 0); } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public TerminalNode LESS_EQUALS() { return getToken(PostgreSqlParser.LESS_EQUALS, 0); } + public TerminalNode GREATER_EQUALS() { return getToken(PostgreSqlParser.GREATER_EQUALS, 0); } + public TerminalNode NOT_EQUALS() { return getToken(PostgreSqlParser.NOT_EQUALS, 0); } + public MathopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mathop; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterMathop(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitMathop(this); + } + } + + public final MathopContext mathop() throws RecognitionException { + MathopContext _localctx = new MathopContext(_ctx, getState()); + enterRule(_localctx, 1272, RULE_mathop); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9492); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 714070016L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Qual_opContext extends ParserRuleContext { + public TerminalNode Operator() { return getToken(PostgreSqlParser.Operator, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Any_operatorContext any_operator() { + return getRuleContext(Any_operatorContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Qual_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qual_op; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterQual_op(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitQual_op(this); + } + } + + public final Qual_opContext qual_op() throws RecognitionException { + Qual_opContext _localctx = new Qual_opContext(_ctx, getState()); + enterRule(_localctx, 1274, RULE_qual_op); + try { + setState(9500); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Operator: + enterOuterAlt(_localctx, 1); + { + setState(9494); + match(Operator); + } + break; + case OPERATOR: + enterOuterAlt(_localctx, 2); + { + setState(9495); + match(OPERATOR); + setState(9496); + match(OPEN_PAREN); + setState(9497); + any_operator(); + setState(9498); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Qual_all_opContext extends ParserRuleContext { + public All_opContext all_op() { + return getRuleContext(All_opContext.class,0); + } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Any_operatorContext any_operator() { + return getRuleContext(Any_operatorContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Qual_all_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qual_all_op; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterQual_all_op(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitQual_all_op(this); + } + } + + public final Qual_all_opContext qual_all_op() throws RecognitionException { + Qual_all_opContext _localctx = new Qual_all_opContext(_ctx, getState()); + enterRule(_localctx, 1276, RULE_qual_all_op); + try { + setState(9508); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: + case EQUAL: + case PLUS: + case MINUS: + case SLASH: + case CARET: + case LT: + case GT: + case LESS_EQUALS: + case GREATER_EQUALS: + case NOT_EQUALS: + case PERCENT: + case Operator: + enterOuterAlt(_localctx, 1); + { + setState(9502); + all_op(); + } + break; + case OPERATOR: + enterOuterAlt(_localctx, 2); + { + setState(9503); + match(OPERATOR); + setState(9504); + match(OPEN_PAREN); + setState(9505); + any_operator(); + setState(9506); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Subquery_OpContext extends ParserRuleContext { + public All_opContext all_op() { + return getRuleContext(All_opContext.class,0); + } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Any_operatorContext any_operator() { + return getRuleContext(Any_operatorContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode LIKE() { return getToken(PostgreSqlParser.LIKE, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode ILIKE() { return getToken(PostgreSqlParser.ILIKE, 0); } + public Subquery_OpContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_subquery_Op; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSubquery_Op(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSubquery_Op(this); + } + } + + public final Subquery_OpContext subquery_Op() throws RecognitionException { + Subquery_OpContext _localctx = new Subquery_OpContext(_ctx, getState()); + enterRule(_localctx, 1278, RULE_subquery_Op); + try { + setState(9522); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,618,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(4860); - match(CASE); - setState(4861); - expr(0); - setState(4867); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(4862); - match(WHEN); - setState(4863); - expr(0); - setState(4864); - match(THEN); - setState(4865); - expr(0); - } - } - setState(4869); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==WHEN ); - setState(4873); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ELSE) { - { - setState(4871); - match(ELSE); - setState(4872); - expr(0); - } - } - - setState(4875); - match(END); + setState(9510); + all_op(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(4877); - match(CASE); - setState(4883); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(4878); - match(WHEN); - setState(4879); - predicate(0); - setState(4880); - match(THEN); - setState(4881); - expr(0); - } - } - setState(4885); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==WHEN ); - setState(4889); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ELSE) { - { - setState(4887); - match(ELSE); - setState(4888); - expr(0); - } + setState(9511); + match(OPERATOR); + setState(9512); + match(OPEN_PAREN); + setState(9513); + any_operator(); + setState(9514); + match(CLOSE_PAREN); } - - setState(4891); - match(END); + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9516); + match(LIKE); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9517); + match(NOT); + setState(9518); + match(LIKE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(9519); + match(ILIKE); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(9520); + match(NOT); + setState(9521); + match(ILIKE); } break; } @@ -41268,14 +79836,12 @@ public class PostgreSqlParser extends Parser { @SuppressWarnings("CheckReturnValue") public static class Expr_listContext extends ParserRuleContext { - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List expr() { - return getRuleContexts(ExprContext.class); + public List a_expr() { + return getRuleContexts(A_exprContext.class); } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(PostgreSqlParser.COMMA, i); @@ -41296,1168 +79862,1064 @@ public class PostgreSqlParser extends Parser { public final Expr_listContext expr_list() throws RecognitionException { Expr_listContext _localctx = new Expr_listContext(_ctx, getState()); - enterRule(_localctx, 452, RULE_expr_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4895); - match(OPEN_PAREN); - setState(4896); - expr(0); - setState(4901); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4897); - match(COMMA); - setState(4898); - expr(0); - } - } - setState(4903); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(4904); - match(CLOSE_PAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Expr_list_listContext extends ParserRuleContext { - public List expr_list() { - return getRuleContexts(Expr_listContext.class); - } - public Expr_listContext expr_list(int i) { - return getRuleContext(Expr_listContext.class,i); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Expr_list_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_expr_list_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExpr_list_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExpr_list_list(this); - } - } - - public final Expr_list_listContext expr_list_list() throws RecognitionException { - Expr_list_listContext _localctx = new Expr_list_listContext(_ctx, getState()); - enterRule(_localctx, 454, RULE_expr_list_list); + enterRule(_localctx, 1280, RULE_expr_list); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(4907); + setState(9524); + a_expr(); + setState(9529); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,578,_ctx) ) { - case 1: - { - setState(4906); - match(OPEN_PAREN); - } - break; - } - setState(4909); - expr_list(); - setState(4914); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,579,_ctx); + _alt = getInterpreter().adaptivePredict(_input,619,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(4910); + setState(9525); match(COMMA); - setState(4911); - expr_list(); + setState(9526); + a_expr(); } } } - setState(4916); + setState(9531); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,579,_ctx); + _alt = getInterpreter().adaptivePredict(_input,619,_ctx); } - setState(4918); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_arg_listContext extends ParserRuleContext { + public List func_arg_expr() { + return getRuleContexts(Func_arg_exprContext.class); + } + public Func_arg_exprContext func_arg_expr(int i) { + return getRuleContext(Func_arg_exprContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Func_arg_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_arg_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_arg_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_arg_list(this); + } + } + + public final Func_arg_listContext func_arg_list() throws RecognitionException { + Func_arg_listContext _localctx = new Func_arg_listContext(_ctx, getState()); + enterRule(_localctx, 1282, RULE_func_arg_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(9532); + func_arg_expr(); + setState(9537); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,580,_ctx) ) { + _alt = getInterpreter().adaptivePredict(_input,620,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(9533); + match(COMMA); + setState(9534); + func_arg_expr(); + } + } + } + setState(9539); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,620,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Func_arg_exprContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Param_nameContext param_name() { + return getRuleContext(Param_nameContext.class,0); + } + public TerminalNode COLON_EQUALS() { return getToken(PostgreSqlParser.COLON_EQUALS, 0); } + public TerminalNode EQUALS_GREATER() { return getToken(PostgreSqlParser.EQUALS_GREATER, 0); } + public Func_arg_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_arg_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_arg_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_arg_expr(this); + } + } + + public final Func_arg_exprContext func_arg_expr() throws RecognitionException { + Func_arg_exprContext _localctx = new Func_arg_exprContext(_ctx, getState()); + enterRule(_localctx, 1284, RULE_func_arg_expr); + int _la; + try { + setState(9545); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,621,_ctx) ) { case 1: - { - setState(4917); - match(CLOSE_PAREN); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Func_sig_argContext extends ParserRuleContext { - public Token argmode; - public IdentifierContext argname; - public Data_typeContext argtype; - public Data_typeContext data_type() { - return getRuleContext(Data_typeContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode IN() { return getToken(PostgreSqlParser.IN, 0); } - public TerminalNode OUT() { return getToken(PostgreSqlParser.OUT, 0); } - public TerminalNode INOUT() { return getToken(PostgreSqlParser.INOUT, 0); } - public TerminalNode VARIADIC() { return getToken(PostgreSqlParser.VARIADIC, 0); } - public Func_sig_argContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_func_sig_arg; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_sig_arg(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_sig_arg(this); - } - } - - public final Func_sig_argContext func_sig_arg() throws RecognitionException { - Func_sig_argContext _localctx = new Func_sig_argContext(_ctx, getState()); - enterRule(_localctx, 456, RULE_func_sig_arg); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4927); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245456777353L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513601L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206585526350118915L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3129962019889872891L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 3170536334544601087L) != 0)) { - { - setState(4921); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,581,_ctx) ) { - case 1: - { - setState(4920); - ((Func_sig_argContext)_localctx).argmode = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==IN || _la==INOUT || _la==OUT || _la==VARIADIC) ) { - ((Func_sig_argContext)_localctx).argmode = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(4924); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,582,_ctx) ) { - case 1: - { - setState(4923); - ((Func_sig_argContext)_localctx).argname = identifier(0); - } - break; - } - setState(4926); - ((Func_sig_argContext)_localctx).argtype = data_type(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Func_sig_arg_listContext extends ParserRuleContext { - public List func_sig_arg() { - return getRuleContexts(Func_sig_argContext.class); - } - public Func_sig_argContext func_sig_arg(int i) { - return getRuleContext(Func_sig_argContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Func_sig_arg_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_func_sig_arg_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_sig_arg_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_sig_arg_list(this); - } - } - - public final Func_sig_arg_listContext func_sig_arg_list() throws RecognitionException { - Func_sig_arg_listContext _localctx = new Func_sig_arg_listContext(_ctx, getState()); - enterRule(_localctx, 458, RULE_func_sig_arg_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4929); - func_sig_arg(); - setState(4934); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4930); - match(COMMA); - setState(4931); - func_sig_arg(); - } - } - setState(4936); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Func_sigContext extends ParserRuleContext { - public IdentifierContext name; - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Func_sig_arg_listContext func_sig_arg_list() { - return getRuleContext(Func_sig_arg_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public Func_sigContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_func_sig; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_sig(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_sig(this); - } - } - - public final Func_sigContext func_sig() throws RecognitionException { - Func_sigContext _localctx = new Func_sigContext(_ctx, getState()); - enterRule(_localctx, 460, RULE_func_sig); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4937); - ((Func_sigContext)_localctx).name = identifier(0); - setState(4942); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OPEN_PAREN) { - { - setState(4938); - match(OPEN_PAREN); - setState(4939); - func_sig_arg_list(); - setState(4940); - match(CLOSE_PAREN); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Func_sig_listContext extends ParserRuleContext { - public List func_sig() { - return getRuleContexts(Func_sigContext.class); - } - public Func_sigContext func_sig(int i) { - return getRuleContext(Func_sigContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Func_sig_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_func_sig_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_sig_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_sig_list(this); - } - } - - public final Func_sig_listContext func_sig_list() throws RecognitionException { - Func_sig_listContext _localctx = new Func_sig_listContext(_ctx, getState()); - enterRule(_localctx, 462, RULE_func_sig_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(4944); - func_sig(); - setState(4949); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(4945); - match(COMMA); - setState(4946); - func_sig(); - } - } - setState(4951); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Type_nameContext extends ParserRuleContext { - public TerminalNode ABSTIME() { return getToken(PostgreSqlParser.ABSTIME, 0); } - public TerminalNode RELTIME() { return getToken(PostgreSqlParser.RELTIME, 0); } - public TerminalNode BIGINT() { return getToken(PostgreSqlParser.BIGINT, 0); } - public TerminalNode BIGSERIAL() { return getToken(PostgreSqlParser.BIGSERIAL, 0); } - public TerminalNode BIT() { return getToken(PostgreSqlParser.BIT, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List INTEGER_LITERAL() { return getTokens(PostgreSqlParser.INTEGER_LITERAL); } - public TerminalNode INTEGER_LITERAL(int i) { - return getToken(PostgreSqlParser.INTEGER_LITERAL, i); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode BIT_VARYING() { return getToken(PostgreSqlParser.BIT_VARYING, 0); } - public TerminalNode BOOL() { return getToken(PostgreSqlParser.BOOL, 0); } - public TerminalNode BOOLEAN() { return getToken(PostgreSqlParser.BOOLEAN, 0); } - public TerminalNode BOX() { return getToken(PostgreSqlParser.BOX, 0); } - public TerminalNode BYTEA() { return getToken(PostgreSqlParser.BYTEA, 0); } - public TerminalNode CHAR() { return getToken(PostgreSqlParser.CHAR, 0); } - public TerminalNode CHARACTER() { return getToken(PostgreSqlParser.CHARACTER, 0); } - public TerminalNode CHARACTER_VARYING() { return getToken(PostgreSqlParser.CHARACTER_VARYING, 0); } - public TerminalNode CIDR() { return getToken(PostgreSqlParser.CIDR, 0); } - public TerminalNode CIRCLE() { return getToken(PostgreSqlParser.CIRCLE, 0); } - public TerminalNode DATE() { return getToken(PostgreSqlParser.DATE, 0); } - public TerminalNode DECIMAL() { return getToken(PostgreSqlParser.DECIMAL, 0); } - public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } - public TerminalNode DOUBLE() { return getToken(PostgreSqlParser.DOUBLE, 0); } - public TerminalNode PRECISION() { return getToken(PostgreSqlParser.PRECISION, 0); } - public TerminalNode FLOAT4() { return getToken(PostgreSqlParser.FLOAT4, 0); } - public TerminalNode FLOAT8() { return getToken(PostgreSqlParser.FLOAT8, 0); } - public TerminalNode INET() { return getToken(PostgreSqlParser.INET, 0); } - public TerminalNode INT() { return getToken(PostgreSqlParser.INT, 0); } - public TerminalNode INT4() { return getToken(PostgreSqlParser.INT4, 0); } - public TerminalNode INT2() { return getToken(PostgreSqlParser.INT2, 0); } - public TerminalNode INT8() { return getToken(PostgreSqlParser.INT8, 0); } - public TerminalNode INTEGER() { return getToken(PostgreSqlParser.INTEGER, 0); } - public TerminalNode INTERVAL() { return getToken(PostgreSqlParser.INTERVAL, 0); } - public TerminalNode FIELDS() { return getToken(PostgreSqlParser.FIELDS, 0); } - public TerminalNode JSON() { return getToken(PostgreSqlParser.JSON, 0); } - public TerminalNode JSONB() { return getToken(PostgreSqlParser.JSONB, 0); } - public TerminalNode LINE() { return getToken(PostgreSqlParser.LINE, 0); } - public TerminalNode LSEG() { return getToken(PostgreSqlParser.LSEG, 0); } - public TerminalNode MACADDR() { return getToken(PostgreSqlParser.MACADDR, 0); } - public TerminalNode MACADDR8() { return getToken(PostgreSqlParser.MACADDR8, 0); } - public TerminalNode MONEY() { return getToken(PostgreSqlParser.MONEY, 0); } - public TerminalNode NUMERIC() { return getToken(PostgreSqlParser.NUMERIC, 0); } - public TerminalNode PATH() { return getToken(PostgreSqlParser.PATH, 0); } - public TerminalNode PG_LSN() { return getToken(PostgreSqlParser.PG_LSN, 0); } - public TerminalNode POINT() { return getToken(PostgreSqlParser.POINT, 0); } - public TerminalNode POLYGON() { return getToken(PostgreSqlParser.POLYGON, 0); } - public TerminalNode REAL() { return getToken(PostgreSqlParser.REAL, 0); } - public TerminalNode SERIAL() { return getToken(PostgreSqlParser.SERIAL, 0); } - public TerminalNode SERIAL2() { return getToken(PostgreSqlParser.SERIAL2, 0); } - public TerminalNode SERIAL4() { return getToken(PostgreSqlParser.SERIAL4, 0); } - public TerminalNode SERIAL8() { return getToken(PostgreSqlParser.SERIAL8, 0); } - public TerminalNode SMALLINT() { return getToken(PostgreSqlParser.SMALLINT, 0); } - public TerminalNode SMALLSERIAL() { return getToken(PostgreSqlParser.SMALLSERIAL, 0); } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public List TIME() { return getTokens(PostgreSqlParser.TIME); } - public TerminalNode TIME(int i) { - return getToken(PostgreSqlParser.TIME, i); - } - public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } - public TerminalNode TIMESTAMP() { return getToken(PostgreSqlParser.TIMESTAMP, 0); } - public TerminalNode TIMETZ() { return getToken(PostgreSqlParser.TIMETZ, 0); } - public TerminalNode TIMESTAMPTZ() { return getToken(PostgreSqlParser.TIMESTAMPTZ, 0); } - public TerminalNode TSQUERY() { return getToken(PostgreSqlParser.TSQUERY, 0); } - public TerminalNode TSVECTOR() { return getToken(PostgreSqlParser.TSVECTOR, 0); } - public TerminalNode TXID_SNAPSHOT() { return getToken(PostgreSqlParser.TXID_SNAPSHOT, 0); } - public TerminalNode UUID() { return getToken(PostgreSqlParser.UUID, 0); } - public TerminalNode VARBIT() { return getToken(PostgreSqlParser.VARBIT, 0); } - public TerminalNode VARCHAR() { return getToken(PostgreSqlParser.VARCHAR, 0); } - public TerminalNode XML() { return getToken(PostgreSqlParser.XML, 0); } - public Type_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type_name; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterType_name(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitType_name(this); - } - } - - public final Type_nameContext type_name() throws RecognitionException { - Type_nameContext _localctx = new Type_nameContext(_ctx, getState()); - enterRule(_localctx, 464, RULE_type_name); - int _la; - try { - setState(5096); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ABSTIME: enterOuterAlt(_localctx, 1); { - setState(4952); - match(ABSTIME); + setState(9540); + a_expr(); } break; - case RELTIME: + case 2: enterOuterAlt(_localctx, 2); { - setState(4953); - match(RELTIME); + setState(9541); + param_name(); + setState(9542); + _la = _input.LA(1); + if ( !(_la==COLON_EQUALS || _la==EQUALS_GREATER) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(9543); + a_expr(); } break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_listContext extends ParserRuleContext { + public List typename() { + return getRuleContexts(TypenameContext.class); + } + public TypenameContext typename(int i) { + return getRuleContext(TypenameContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Type_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterType_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitType_list(this); + } + } + + public final Type_listContext type_list() throws RecognitionException { + Type_listContext _localctx = new Type_listContext(_ctx, getState()); + enterRule(_localctx, 1286, RULE_type_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9547); + typename(); + setState(9552); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(9548); + match(COMMA); + setState(9549); + typename(); + } + } + setState(9554); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Array_exprContext extends ParserRuleContext { + public TerminalNode OPEN_BRACKET() { return getToken(PostgreSqlParser.OPEN_BRACKET, 0); } + public TerminalNode CLOSE_BRACKET() { return getToken(PostgreSqlParser.CLOSE_BRACKET, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Array_expr_listContext array_expr_list() { + return getRuleContext(Array_expr_listContext.class,0); + } + public Array_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_array_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterArray_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitArray_expr(this); + } + } + + public final Array_exprContext array_expr() throws RecognitionException { + Array_exprContext _localctx = new Array_exprContext(_ctx, getState()); + enterRule(_localctx, 1288, RULE_array_expr); + try { + enterOuterAlt(_localctx, 1); + { + setState(9555); + match(OPEN_BRACKET); + setState(9558); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case COLON: + case QUESTION: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNIQUE: + case USER: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: case BIGINT: - enterOuterAlt(_localctx, 3); - { - setState(4954); - match(BIGINT); - } - break; - case BIGSERIAL: - enterOuterAlt(_localctx, 4); - { - setState(4955); - match(BIGSERIAL); - } - break; case BIT: - enterOuterAlt(_localctx, 5); - { - setState(4956); - match(BIT); - setState(4960); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,587,_ctx) ) { - case 1: - { - setState(4957); - match(OPEN_PAREN); - setState(4958); - match(INTEGER_LITERAL); - setState(4959); - match(CLOSE_PAREN); - } - break; - } - } - break; - case BIT_VARYING: - enterOuterAlt(_localctx, 6); - { - setState(4962); - match(BIT_VARYING); - setState(4966); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,588,_ctx) ) { - case 1: - { - setState(4963); - match(OPEN_PAREN); - setState(4964); - match(INTEGER_LITERAL); - setState(4965); - match(CLOSE_PAREN); - } - break; - } - } - break; - case BOOL: - enterOuterAlt(_localctx, 7); - { - setState(4968); - match(BOOL); - } - break; - case BOOLEAN: - enterOuterAlt(_localctx, 8); - { - setState(4969); - match(BOOLEAN); - } - break; - case BOX: - enterOuterAlt(_localctx, 9); - { - setState(4970); - match(BOX); - } - break; - case BYTEA: - enterOuterAlt(_localctx, 10); - { - setState(4971); - match(BYTEA); - } - break; - case CHAR: - enterOuterAlt(_localctx, 11); - { - setState(4972); - match(CHAR); - setState(4976); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,589,_ctx) ) { - case 1: - { - setState(4973); - match(OPEN_PAREN); - setState(4974); - match(INTEGER_LITERAL); - setState(4975); - match(CLOSE_PAREN); - } - break; - } - } - break; + case BOOLEAN_P: + case CHAR_P: case CHARACTER: - enterOuterAlt(_localctx, 12); - { - setState(4978); - match(CHARACTER); - setState(4982); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,590,_ctx) ) { - case 1: - { - setState(4979); - match(OPEN_PAREN); - setState(4980); - match(INTEGER_LITERAL); - setState(4981); - match(CLOSE_PAREN); - } - break; - } - } - break; - case CHARACTER_VARYING: - enterOuterAlt(_localctx, 13); - { - setState(4984); - match(CHARACTER_VARYING); - setState(4988); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,591,_ctx) ) { - case 1: - { - setState(4985); - match(OPEN_PAREN); - setState(4986); - match(INTEGER_LITERAL); - setState(4987); - match(CLOSE_PAREN); - } - break; - } - } - break; - case CIDR: - enterOuterAlt(_localctx, 14); - { - setState(4990); - match(CIDR); - } - break; - case CIRCLE: - enterOuterAlt(_localctx, 15); - { - setState(4991); - match(CIRCLE); - } - break; - case DATE: - enterOuterAlt(_localctx, 16); - { - setState(4992); - match(DATE); - } - break; - case DECIMAL: - enterOuterAlt(_localctx, 17); - { - setState(4993); - match(DECIMAL); - setState(4999); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,592,_ctx) ) { - case 1: - { - setState(4994); - match(OPEN_PAREN); - setState(4995); - match(INTEGER_LITERAL); - setState(4996); - match(COMMA); - setState(4997); - match(INTEGER_LITERAL); - setState(4998); - match(CLOSE_PAREN); - } - break; - } - } - break; - case DOUBLE: - enterOuterAlt(_localctx, 18); - { - setState(5001); - match(DOUBLE); - setState(5002); - match(PRECISION); - } - break; - case FLOAT4: - enterOuterAlt(_localctx, 19); - { - setState(5003); - match(FLOAT4); - } - break; - case FLOAT8: - enterOuterAlt(_localctx, 20); - { - setState(5004); - match(FLOAT8); - } - break; - case INET: - enterOuterAlt(_localctx, 21); - { - setState(5005); - match(INET); - } - break; - case INT: - enterOuterAlt(_localctx, 22); - { - setState(5006); - match(INT); - } - break; - case INT4: - enterOuterAlt(_localctx, 23); - { - setState(5007); - match(INT4); - } - break; - case INT2: - enterOuterAlt(_localctx, 24); - { - setState(5008); - match(INT2); - } - break; - case INT8: - enterOuterAlt(_localctx, 25); - { - setState(5009); - match(INT8); - } - break; + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: case INTEGER: - enterOuterAlt(_localctx, 26); - { - setState(5010); - match(INTEGER); - } - break; case INTERVAL: - enterOuterAlt(_localctx, 27); - { - setState(5011); - match(INTERVAL); - setState(5013); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,593,_ctx) ) { - case 1: - { - setState(5012); - match(FIELDS); - } - break; - } - setState(5016); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,594,_ctx) ) { - case 1: - { - setState(5015); - match(INTEGER_LITERAL); - } - break; - } - } - break; - case JSON: - enterOuterAlt(_localctx, 28); - { - setState(5018); - match(JSON); - } - break; - case JSONB: - enterOuterAlt(_localctx, 29); - { - setState(5019); - match(JSONB); - } - break; - case LINE: - enterOuterAlt(_localctx, 30); - { - setState(5020); - match(LINE); - } - break; - case LSEG: - enterOuterAlt(_localctx, 31); - { - setState(5021); - match(LSEG); - } - break; - case MACADDR: - enterOuterAlt(_localctx, 32); - { - setState(5022); - match(MACADDR); - } - break; - case MACADDR8: - enterOuterAlt(_localctx, 33); - { - setState(5023); - match(MACADDR8); - } - break; - case MONEY: - enterOuterAlt(_localctx, 34); - { - setState(5024); - match(MONEY); - } - break; + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: case NUMERIC: - enterOuterAlt(_localctx, 35); - { - setState(5025); - match(NUMERIC); - setState(5031); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,595,_ctx) ) { - case 1: - { - setState(5026); - match(OPEN_PAREN); - setState(5027); - match(INTEGER_LITERAL); - setState(5028); - match(COMMA); - setState(5029); - match(INTEGER_LITERAL); - setState(5030); - match(CLOSE_PAREN); - } - break; - } - } - break; - case PATH: - enterOuterAlt(_localctx, 36); - { - setState(5033); - match(PATH); - } - break; - case PG_LSN: - enterOuterAlt(_localctx, 37); - { - setState(5034); - match(PG_LSN); - } - break; - case POINT: - enterOuterAlt(_localctx, 38); - { - setState(5035); - match(POINT); - } - break; - case POLYGON: - enterOuterAlt(_localctx, 39); - { - setState(5036); - match(POLYGON); - } - break; + case OVERLAY: + case POSITION: + case PRECISION: case REAL: - enterOuterAlt(_localctx, 40); - { - setState(5037); - match(REAL); - } - break; - case SERIAL: - enterOuterAlt(_localctx, 41); - { - setState(5038); - match(SERIAL); - } - break; - case SERIAL2: - enterOuterAlt(_localctx, 42); - { - setState(5039); - match(SERIAL2); - } - break; - case SERIAL4: - enterOuterAlt(_localctx, 43); - { - setState(5040); - match(SERIAL4); - } - break; - case SERIAL8: - enterOuterAlt(_localctx, 44); - { - setState(5041); - match(SERIAL8); - } - break; + case ROW: + case SETOF: case SMALLINT: - enterOuterAlt(_localctx, 45); - { - setState(5042); - match(SMALLINT); - } - break; - case SMALLSERIAL: - enterOuterAlt(_localctx, 46); - { - setState(5043); - match(SMALLSERIAL); - } - break; - case TEXT: - enterOuterAlt(_localctx, 47); - { - setState(5044); - match(TEXT); - } - break; + case SUBSTRING: case TIME: - enterOuterAlt(_localctx, 48); - { - setState(5045); - match(TIME); - setState(5049); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,596,_ctx) ) { - case 1: - { - setState(5046); - match(OPEN_PAREN); - setState(5047); - match(INTEGER_LITERAL); - setState(5048); - match(CLOSE_PAREN); - } - break; - } - setState(5054); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,597,_ctx) ) { - case 1: - { - setState(5051); - _la = _input.LA(1); - if ( !(_la==WITH || _la==WITHOUT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(5052); - match(TIME); - setState(5053); - match(ZONE); - } - break; - } - } - break; case TIMESTAMP: - enterOuterAlt(_localctx, 49); - { - setState(5056); - match(TIMESTAMP); - setState(5060); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,598,_ctx) ) { - case 1: - { - setState(5057); - match(OPEN_PAREN); - setState(5058); - match(INTEGER_LITERAL); - setState(5059); - match(CLOSE_PAREN); - } - break; - } - setState(5065); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,599,_ctx) ) { - case 1: - { - setState(5062); - _la = _input.LA(1); - if ( !(_la==WITH || _la==WITHOUT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(5063); - match(TIME); - setState(5064); - match(ZONE); - } - break; - } - } - break; - case TIMETZ: - enterOuterAlt(_localctx, 50); - { - setState(5067); - match(TIMETZ); - setState(5071); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,600,_ctx) ) { - case 1: - { - setState(5068); - match(OPEN_PAREN); - setState(5069); - match(INTEGER_LITERAL); - setState(5070); - match(CLOSE_PAREN); - } - break; - } - } - break; - case TIMESTAMPTZ: - enterOuterAlt(_localctx, 51); - { - setState(5073); - match(TIMESTAMPTZ); - setState(5077); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,601,_ctx) ) { - case 1: - { - setState(5074); - match(OPEN_PAREN); - setState(5075); - match(INTEGER_LITERAL); - setState(5076); - match(CLOSE_PAREN); - } - break; - } - } - break; - case TSQUERY: - enterOuterAlt(_localctx, 52); - { - setState(5079); - match(TSQUERY); - } - break; - case TSVECTOR: - enterOuterAlt(_localctx, 53); - { - setState(5080); - match(TSVECTOR); - } - break; - case TXID_SNAPSHOT: - enterOuterAlt(_localctx, 54); - { - setState(5081); - match(TXID_SNAPSHOT); - } - break; - case UUID: - enterOuterAlt(_localctx, 55); - { - setState(5082); - match(UUID); - } - break; - case VARBIT: - enterOuterAlt(_localctx, 56); - { - setState(5083); - match(VARBIT); - setState(5087); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,602,_ctx) ) { - case 1: - { - setState(5084); - match(OPEN_PAREN); - setState(5085); - match(INTEGER_LITERAL); - setState(5086); - match(CLOSE_PAREN); - } - break; - } - } - break; + case TREAT: + case TRIM: + case VALUES: case VARCHAR: - enterOuterAlt(_localctx, 57); + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: { - setState(5089); - match(VARCHAR); - setState(5093); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,603,_ctx) ) { - case 1: - { - setState(5090); - match(OPEN_PAREN); - setState(5091); - match(INTEGER_LITERAL); - setState(5092); - match(CLOSE_PAREN); - } - break; - } + setState(9556); + expr_list(); } break; - case XML: - enterOuterAlt(_localctx, 58); + case OPEN_BRACKET: + { + setState(9557); + array_expr_list(); + } + break; + case CLOSE_BRACKET: + break; + default: + break; + } + setState(9560); + match(CLOSE_BRACKET); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Array_expr_listContext extends ParserRuleContext { + public List array_expr() { + return getRuleContexts(Array_exprContext.class); + } + public Array_exprContext array_expr(int i) { + return getRuleContext(Array_exprContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Array_expr_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_array_expr_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterArray_expr_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitArray_expr_list(this); + } + } + + public final Array_expr_listContext array_expr_list() throws RecognitionException { + Array_expr_listContext _localctx = new Array_expr_listContext(_ctx, getState()); + enterRule(_localctx, 1290, RULE_array_expr_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9562); + array_expr(); + setState(9567); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(9563); + match(COMMA); + setState(9564); + array_expr(); + } + } + setState(9569); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Extract_listContext extends ParserRuleContext { + public Extract_argContext extract_arg() { + return getRuleContext(Extract_argContext.class,0); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Extract_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_extract_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExtract_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExtract_list(this); + } + } + + public final Extract_listContext extract_list() throws RecognitionException { + Extract_listContext _localctx = new Extract_listContext(_ctx, getState()); + enterRule(_localctx, 1292, RULE_extract_list); + try { + setState(9575); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case OUTER_P: + case ABSOLUTE_P: + case BACKWARD: + case CHAIN: + case CLOSE: + case COMMIT: + case CONTINUE_P: + case CURSOR: + case DAY_P: + case FIRST_P: + case FORWARD: + case HOUR_P: + case INSERT: + case LAST_P: + case MINUTE_P: + case MONTH_P: + case MOVE: + case NEXT: + case NO: + case OPTION: + case PRIOR: + case RELATIVE_P: + case RESET: + case ROLLBACK: + case SCHEMA: + case SCROLL: + case SECOND_P: + case SET: + case TYPE_P: + case YEAR_P: + case CALL: + case CURRENT_P: + case ROWTYPE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(9570); + extract_arg(); + setState(9571); + match(FROM); + setState(9572); + a_expr(); + } + break; + case CLOSE_PAREN: + enterOuterAlt(_localctx, 2); { - setState(5095); - match(XML); } break; default: @@ -42476,35 +80938,210 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class TimezoneContext extends ParserRuleContext { - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public TerminalNode DOUBLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.DOUBLEQ_STRING_LITERAL, 0); } - public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } - public TerminalNode NUMERIC_LITERAL() { return getToken(PostgreSqlParser.NUMERIC_LITERAL, 0); } - public TimezoneContext(ParserRuleContext parent, int invokingState) { + public static class Extract_argContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode YEAR_P() { return getToken(PostgreSqlParser.YEAR_P, 0); } + public TerminalNode MONTH_P() { return getToken(PostgreSqlParser.MONTH_P, 0); } + public TerminalNode DAY_P() { return getToken(PostgreSqlParser.DAY_P, 0); } + public TerminalNode HOUR_P() { return getToken(PostgreSqlParser.HOUR_P, 0); } + public TerminalNode MINUTE_P() { return getToken(PostgreSqlParser.MINUTE_P, 0); } + public TerminalNode SECOND_P() { return getToken(PostgreSqlParser.SECOND_P, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Extract_argContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_timezone; } + @Override public int getRuleIndex() { return RULE_extract_arg; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTimezone(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExtract_arg(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTimezone(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExtract_arg(this); } } - public final TimezoneContext timezone() throws RecognitionException { - TimezoneContext _localctx = new TimezoneContext(_ctx, getState()); - enterRule(_localctx, 466, RULE_timezone); + public final Extract_argContext extract_arg() throws RecognitionException { + Extract_argContext _localctx = new Extract_argContext(_ctx, getState()); + enterRule(_localctx, 1294, RULE_extract_arg); + try { + setState(9585); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case OUTER_P: + case ABSOLUTE_P: + case BACKWARD: + case CHAIN: + case CLOSE: + case COMMIT: + case CONTINUE_P: + case CURSOR: + case FIRST_P: + case FORWARD: + case INSERT: + case LAST_P: + case MOVE: + case NEXT: + case NO: + case OPTION: + case PRIOR: + case RELATIVE_P: + case RESET: + case ROLLBACK: + case SCHEMA: + case SCROLL: + case SET: + case TYPE_P: + case CALL: + case CURRENT_P: + case ROWTYPE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(9577); + identifier(); + } + break; + case YEAR_P: + enterOuterAlt(_localctx, 2); + { + setState(9578); + match(YEAR_P); + } + break; + case MONTH_P: + enterOuterAlt(_localctx, 3); + { + setState(9579); + match(MONTH_P); + } + break; + case DAY_P: + enterOuterAlt(_localctx, 4); + { + setState(9580); + match(DAY_P); + } + break; + case HOUR_P: + enterOuterAlt(_localctx, 5); + { + setState(9581); + match(HOUR_P); + } + break; + case MINUTE_P: + enterOuterAlt(_localctx, 6); + { + setState(9582); + match(MINUTE_P); + } + break; + case SECOND_P: + enterOuterAlt(_localctx, 7); + { + setState(9583); + match(SECOND_P); + } + break; + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + enterOuterAlt(_localctx, 8); + { + setState(9584); + sconst(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Unicode_normal_formContext extends ParserRuleContext { + public TerminalNode NFC() { return getToken(PostgreSqlParser.NFC, 0); } + public TerminalNode NFD() { return getToken(PostgreSqlParser.NFD, 0); } + public TerminalNode NFKC() { return getToken(PostgreSqlParser.NFKC, 0); } + public TerminalNode NFKD() { return getToken(PostgreSqlParser.NFKD, 0); } + public Unicode_normal_formContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unicode_normal_form; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUnicode_normal_form(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUnicode_normal_form(this); + } + } + + public final Unicode_normal_formContext unicode_normal_form() throws RecognitionException { + Unicode_normal_formContext _localctx = new Unicode_normal_formContext(_ctx, getState()); + enterRule(_localctx, 1296, RULE_unicode_normal_form); int _la; try { enterOuterAlt(_localctx, 1); { - setState(5098); + setState(9587); _la = _input.LA(1); - if ( !(((((_la - 774)) & ~0x3f) == 0 && ((1L << (_la - 774)) & 51L) != 0)) ) { + if ( !(((((_la - 485)) & ~0x3f) == 0 && ((1L << (_la - 485)) & 15L) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -42526,294 +81163,59 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class OperContext extends ParserRuleContext { - public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } - public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public OperContext(ParserRuleContext parent, int invokingState) { + public static class Overlay_listContext extends ParserRuleContext { + public List a_expr() { + return getRuleContexts(A_exprContext.class); + } + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public TerminalNode PLACING() { return getToken(PostgreSqlParser.PLACING, 0); } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Overlay_listContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_oper; } + @Override public int getRuleIndex() { return RULE_overlay_list; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOper(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOverlay_list(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOper(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOverlay_list(this); } } - public final OperContext oper() throws RecognitionException { - OperContext _localctx = new OperContext(_ctx, getState()); - enterRule(_localctx, 468, RULE_oper); - try { - setState(5104); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,605,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(5101); - match(IS); - setState(5102); - match(OF); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(5103); - match(ALL); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class AggregateContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Order_by_clauseContext order_by_clause() { - return getRuleContext(Order_by_clauseContext.class,0); - } - public TerminalNode FILTER() { return getToken(PostgreSqlParser.FILTER, 0); } - public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } - public Where_clauseContext where_clause() { - return getRuleContext(Where_clauseContext.class,0); - } - public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } - public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public TerminalNode WITHIN() { return getToken(PostgreSqlParser.WITHIN, 0); } - public TerminalNode GROUP() { return getToken(PostgreSqlParser.GROUP, 0); } - public AggregateContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_aggregate; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAggregate(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAggregate(this); - } - } - - public final AggregateContext aggregate() throws RecognitionException { - AggregateContext _localctx = new AggregateContext(_ctx, getState()); - enterRule(_localctx, 470, RULE_aggregate); + public final Overlay_listContext overlay_list() throws RecognitionException { + Overlay_listContext _localctx = new Overlay_listContext(_ctx, getState()); + enterRule(_localctx, 1298, RULE_overlay_list); int _la; try { - setState(5169); + enterOuterAlt(_localctx, 1); + { + setState(9589); + a_expr(); + setState(9590); + match(PLACING); + setState(9591); + a_expr(); + setState(9592); + match(FROM); + setState(9593); + a_expr(); + setState(9596); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,614,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); + _la = _input.LA(1); + if (_la==FOR) { { - setState(5106); - identifier(0); - setState(5107); - match(OPEN_PAREN); - setState(5109); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,606,_ctx) ) { - case 1: - { - setState(5108); - _la = _input.LA(1); - if ( !(_la==ALL || _la==DISTINCT) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - } - setState(5111); - expr(0); - setState(5116); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5112); - match(COMMA); - setState(5113); - expr(0); - } - } - setState(5118); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(5120); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ORDER) { - { - setState(5119); - order_by_clause(); - } + setState(9594); + match(FOR); + setState(9595); + a_expr(); } + } - setState(5122); - match(CLOSE_PAREN); - setState(5129); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,609,_ctx) ) { - case 1: - { - setState(5123); - match(FILTER); - setState(5124); - match(OPEN_PAREN); - setState(5125); - match(WHERE); - setState(5126); - where_clause(); - setState(5127); - match(CLOSE_PAREN); - } - break; - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(5131); - identifier(0); - setState(5132); - match(OPEN_PAREN); - setState(5133); - match(STAR); - setState(5134); - match(CLOSE_PAREN); - setState(5141); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,610,_ctx) ) { - case 1: - { - setState(5135); - match(FILTER); - setState(5136); - match(OPEN_PAREN); - setState(5137); - match(WHERE); - setState(5138); - where_clause(); - setState(5139); - match(CLOSE_PAREN); - } - break; - } - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(5143); - identifier(0); - setState(5144); - match(OPEN_PAREN); - setState(5153); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -11575800568512526L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334777102337L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245452583049L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206567384408260611L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & -6102417216219643909L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 4537576733544546303L) != 0) || ((((_la - 788)) & ~0x3f) == 0 && ((1L << (_la - 788)) & 1262854602757L) != 0)) { - { - setState(5145); - expr(0); - setState(5150); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5146); - match(COMMA); - setState(5147); - expr(0); - } - } - setState(5152); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(5155); - match(CLOSE_PAREN); - setState(5156); - match(WITHIN); - setState(5157); - match(GROUP); - setState(5158); - match(OPEN_PAREN); - setState(5159); - order_by_clause(); - setState(5160); - match(CLOSE_PAREN); - setState(5167); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,613,_ctx) ) { - case 1: - { - setState(5161); - match(FILTER); - setState(5162); - match(OPEN_PAREN); - setState(5163); - match(WHERE); - setState(5164); - where_clause(); - setState(5165); - match(CLOSE_PAREN); - } - break; - } - } - break; } } catch (RecognitionException re) { @@ -42828,591 +81230,616 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Name_Context extends ParserRuleContext { - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public static class Position_listContext extends ParserRuleContext { + public List b_expr() { + return getRuleContexts(B_exprContext.class); } - public Name_Context(ParserRuleContext parent, int invokingState) { + public B_exprContext b_expr(int i) { + return getRuleContext(B_exprContext.class,i); + } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public Position_listContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_name_; } + @Override public int getRuleIndex() { return RULE_position_list; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterName_(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPosition_list(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitName_(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPosition_list(this); } } - public final Name_Context name_() throws RecognitionException { - Name_Context _localctx = new Name_Context(_ctx, getState()); - enterRule(_localctx, 472, RULE_name_); + public final Position_listContext position_list() throws RecognitionException { + Position_listContext _localctx = new Position_listContext(_ctx, getState()); + enterRule(_localctx, 1300, RULE_position_list); try { - setState(5173); + setState(9603); _errHandler.sync(this); switch (_input.LA(1)) { - case SINGLEQ_STRING_LITERAL: - enterOuterAlt(_localctx, 1); - { - setState(5171); - match(SINGLEQ_STRING_LITERAL); - } - break; - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: + case OPEN_PAREN: + case COLON: + case QUESTION: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case LOCALTIME: + case LOCALTIMESTAMP: + case NULL_P: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNIQUE: + case USER: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: case ACCESS: case ACTION: - case ADA: - case ADD: + case ADD_P: case ADMIN: case AFTER: case AGGREGATE: - case ALLOCATE: case ALSO: case ALTER: case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: case ASSERTION: case ASSIGNMENT: case AT: - case ATOMIC: case ATTRIBUTE: - case ATTRIBUTES: - case AVG: case BACKWARD: case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: + case BEGIN_P: case BY: - case C_: case CACHE: - case CALL: case CALLED: - case CARDINALITY: case CASCADE: case CASCADED: case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: case CHARACTERISTICS: - case CHARACTERS: case CHECKPOINT: case CLASS: - case CLASS_ORIGIN: - case CLOB: case CLOSE: case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: case COMMENT: + case COMMENTS: case COMMIT: case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: + case CONFIGURATION: case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: + case COST: case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: case CURSOR: - case CURSOR_NAME: case CYCLE: - case DATA: + case DATA_P: case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: + case DAY_P: case DEALLOCATE: - case DEC: - case DECIMAL: case DECLARE: case DEFAULTS: case DEFERRED: - case DEFINED: case DEFINER: - case DEGREE: - case DELETE: + case DELETE_P: case DELIMITER: case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: case EACH: - case ELEMENT: + case ENABLE_P: case ENCODING: case ENCRYPTED: - case END: - case EQUALS: + case ENUM_P: case ESCAPE: - case EVERY: - case EXCEPTION: + case EVENT: case EXCLUDE: case EXCLUDING: case EXCLUSIVE: - case EXEC: case EXECUTE: - case EXISTS: - case EXP: case EXPLAIN: case EXTENSION: case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: + case FAMILY: + case FIRST_P: case FOLLOWING: case FORCE: - case FORMAT: - case FORTRAN: case FORWARD: - case FOUND: - case FREE: case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: + case FUNCTIONS: case GLOBAL: - case GO: - case GOTO: case GRANTED: - case GREATEST: - case GROUPING: case HANDLER: - case HIERARCHY: + case HEADER_P: case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: + case HOUR_P: + case IDENTITY_P: + case IF_P: case IMMEDIATE: case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: + case IMPLICIT_P: case INCLUDING: case INCREMENT: case INDEX: - case INDICATOR: + case INDEXES: + case INHERIT: case INHERITS: - case INOUT: - case INPUT: + case INLINE_P: case INSENSITIVE: case INSERT: - case INSTANCE: - case INSTANTIABLE: case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: case INVOKER: case ISOLATION: - case K_: case KEY: - case KEY_MEMBER: - case KEY_TYPE: + case LABEL: case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: + case LARGE_P: + case LAST_P: + case LEAKPROOF: case LEVEL: case LISTEN: - case LN: case LOAD: case LOCAL: case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: + case LOCK_P: + case MAPPING: case MATCH: - case MATCHED: - case MAX: + case MATERIALIZED: case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: + case MINUTE_P: case MINVALUE: - case MOD: case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: + case MONTH_P: case MOVE: - case MULTISET: - case MUMPS: - case NAME: + case NAME_P: case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: case NEXT: case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: case NOTHING: case NOTIFY: case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: + case NULLS_P: + case OBJECT_P: case OF: case OFF: case OIDS: - case OLD: - case OPEN: case OPERATOR: case OPTION: case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: + case OWNED: case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: + case PARSER: case PARTIAL: case PARTITION: - case PASCAL: + case PASSING: case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: + case PLANS: case PRECEDING: - case PRECISION: case PREPARE: + case PREPARED: case PRESERVE: case PRIOR: case PRIVILEGES: case PROCEDURAL: case PROCEDURE: - case PUBLIC: + case PROGRAM: case QUOTE: case RANGE: - case RANK: case READ: - case READS: - case REAL: + case REASSIGN: case RECHECK: case RECURSIVE: case REF: - case REFERENCING: case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: case REINDEX: - case RELATIVE: + case RELATIVE_P: case RELEASE: case RENAME: case REPEATABLE: case REPLACE: + case REPLICA: case RESET: case RESTART: case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: case RETURNS: case REVOKE: - case RIGHT: case ROLE: case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: case ROWS: case RULE: case SAVEPOINT: - case SCALE: case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: case SCROLL: case SEARCH: - case SECOND: - case SECTION: + case SECOND_P: case SECURITY: - case SELF: - case SENSITIVE: case SEQUENCE: case SEQUENCES: case SERIALIZABLE: - case SERVER_NAME: + case SERVER: case SESSION: case SET: - case SETOF: - case SETS: case SHARE: case SHOW: case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: + case SNAPSHOT: case STABLE: + case STANDALONE_P: case START: - case STATE: case STATEMENT: - case STATIC: case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: case STDIN: case STDOUT: case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: + case STRICT_P: + case STRIP_P: case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: + case SYSTEM_P: + case TABLES: case TABLESPACE: case TEMP: case TEMPLATE: case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: + case TEXT_P: case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: case TRUNCATE: case TRUSTED: - case TYPE: - case UESCAPE: + case TYPE_P: + case TYPES_P: case UNBOUNDED: case UNCOMMITTED: - case UNDER: case UNENCRYPTED: case UNKNOWN: case UNLISTEN: - case UNNAMED: - case UNNEST: + case UNLOGGED: case UNTIL: case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: case VACUUM: case VALID: + case VALIDATE: case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: case VARYING: + case VERSION_P: case VIEW: case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: + case WHITESPACE_P: case WITHOUT: case WORK: + case WRAPPER: case WRITE: - case YEAR: + case XML_P: + case YEAR_P: + case YES_P: case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(9598); + b_expr(0); + setState(9599); + match(IN_P); + setState(9600); + b_expr(0); + } + break; + case CLOSE_PAREN: enterOuterAlt(_localctx, 2); { - setState(5172); - identifier(0); } break; default: @@ -43431,12 +81858,2975 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Name_listContext extends ParserRuleContext { - public List name_() { - return getRuleContexts(Name_Context.class); + public static class Substr_listContext extends ParserRuleContext { + public List a_expr() { + return getRuleContexts(A_exprContext.class); } - public Name_Context name_(int i) { - return getRuleContext(Name_Context.class,i); + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode SIMILAR() { return getToken(PostgreSqlParser.SIMILAR, 0); } + public TerminalNode ESCAPE() { return getToken(PostgreSqlParser.ESCAPE, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Substr_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_substr_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSubstr_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSubstr_list(this); + } + } + + public final Substr_listContext substr_list() throws RecognitionException { + Substr_listContext _localctx = new Substr_listContext(_ctx, getState()); + enterRule(_localctx, 1302, RULE_substr_list); + try { + setState(9632); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,629,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9605); + a_expr(); + setState(9606); + match(FROM); + setState(9607); + a_expr(); + setState(9608); + match(FOR); + setState(9609); + a_expr(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9611); + a_expr(); + setState(9612); + match(FOR); + setState(9613); + a_expr(); + setState(9614); + match(FROM); + setState(9615); + a_expr(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9617); + a_expr(); + setState(9618); + match(FROM); + setState(9619); + a_expr(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9621); + a_expr(); + setState(9622); + match(FOR); + setState(9623); + a_expr(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(9625); + a_expr(); + setState(9626); + match(SIMILAR); + setState(9627); + a_expr(); + setState(9628); + match(ESCAPE); + setState(9629); + a_expr(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(9631); + expr_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Trim_listContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Trim_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_trim_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTrim_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTrim_list(this); + } + } + + public final Trim_listContext trim_list() throws RecognitionException { + Trim_listContext _localctx = new Trim_listContext(_ctx, getState()); + enterRule(_localctx, 1304, RULE_trim_list); + try { + setState(9641); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,630,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9634); + a_expr(); + setState(9635); + match(FROM); + setState(9636); + expr_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9638); + match(FROM); + setState(9639); + expr_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9640); + expr_list(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class In_exprContext extends ParserRuleContext { + public In_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_in_expr; } + + public In_exprContext() { } + public void copyFrom(In_exprContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class In_expr_listContext extends In_exprContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public In_expr_listContext(In_exprContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIn_expr_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIn_expr_list(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class In_expr_selectContext extends In_exprContext { + public Select_with_parensContext select_with_parens() { + return getRuleContext(Select_with_parensContext.class,0); + } + public In_expr_selectContext(In_exprContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIn_expr_select(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIn_expr_select(this); + } + } + + public final In_exprContext in_expr() throws RecognitionException { + In_exprContext _localctx = new In_exprContext(_ctx, getState()); + enterRule(_localctx, 1306, RULE_in_expr); + try { + setState(9648); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,631,_ctx) ) { + case 1: + _localctx = new In_expr_selectContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(9643); + select_with_parens(); + } + break; + case 2: + _localctx = new In_expr_listContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(9644); + match(OPEN_PAREN); + setState(9645); + expr_list(); + setState(9646); + match(CLOSE_PAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Case_exprContext extends ParserRuleContext { + public TerminalNode CASE() { return getToken(PostgreSqlParser.CASE, 0); } + public Case_argContext case_arg() { + return getRuleContext(Case_argContext.class,0); + } + public When_clause_listContext when_clause_list() { + return getRuleContext(When_clause_listContext.class,0); + } + public Case_defaultContext case_default() { + return getRuleContext(Case_defaultContext.class,0); + } + public TerminalNode END_P() { return getToken(PostgreSqlParser.END_P, 0); } + public Case_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_case_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCase_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCase_expr(this); + } + } + + public final Case_exprContext case_expr() throws RecognitionException { + Case_exprContext _localctx = new Case_exprContext(_ctx, getState()); + enterRule(_localctx, 1308, RULE_case_expr); + try { + enterOuterAlt(_localctx, 1); + { + setState(9650); + match(CASE); + setState(9651); + case_arg(); + setState(9652); + when_clause_list(); + setState(9653); + case_default(); + setState(9654); + match(END_P); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class When_clause_listContext extends ParserRuleContext { + public List when_clause() { + return getRuleContexts(When_clauseContext.class); + } + public When_clauseContext when_clause(int i) { + return getRuleContext(When_clauseContext.class,i); + } + public When_clause_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_when_clause_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWhen_clause_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWhen_clause_list(this); + } + } + + public final When_clause_listContext when_clause_list() throws RecognitionException { + When_clause_listContext _localctx = new When_clause_listContext(_ctx, getState()); + enterRule(_localctx, 1310, RULE_when_clause_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9657); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(9656); + when_clause(); + } + } + setState(9659); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHEN ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class When_clauseContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public List a_expr() { + return getRuleContexts(A_exprContext.class); + } + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public TerminalNode THEN() { return getToken(PostgreSqlParser.THEN, 0); } + public When_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_when_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWhen_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWhen_clause(this); + } + } + + public final When_clauseContext when_clause() throws RecognitionException { + When_clauseContext _localctx = new When_clauseContext(_ctx, getState()); + enterRule(_localctx, 1312, RULE_when_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(9661); + match(WHEN); + setState(9662); + a_expr(); + setState(9663); + match(THEN); + setState(9664); + a_expr(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Case_defaultContext extends ParserRuleContext { + public TerminalNode ELSE() { return getToken(PostgreSqlParser.ELSE, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Case_defaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_case_default; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCase_default(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCase_default(this); + } + } + + public final Case_defaultContext case_default() throws RecognitionException { + Case_defaultContext _localctx = new Case_defaultContext(_ctx, getState()); + enterRule(_localctx, 1314, RULE_case_default); + try { + setState(9669); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ELSE: + enterOuterAlt(_localctx, 1); + { + setState(9666); + match(ELSE); + setState(9667); + a_expr(); + } + break; + case END_P: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Case_argContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Case_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_case_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCase_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCase_arg(this); + } + } + + public final Case_argContext case_arg() throws RecognitionException { + Case_argContext _localctx = new Case_argContext(_ctx, getState()); + enterRule(_localctx, 1316, RULE_case_arg); + try { + setState(9673); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case COLON: + case QUESTION: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNIQUE: + case USER: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 1); + { + setState(9671); + a_expr(); + } + break; + case WHEN: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColumnrefContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public IndirectionContext indirection() { + return getRuleContext(IndirectionContext.class,0); + } + public ColumnrefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_columnref; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumnref(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumnref(this); + } + } + + public final ColumnrefContext columnref() throws RecognitionException { + ColumnrefContext _localctx = new ColumnrefContext(_ctx, getState()); + enterRule(_localctx, 1318, RULE_columnref); + try { + enterOuterAlt(_localctx, 1); + { + setState(9675); + colid(); + setState(9677); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,635,_ctx) ) { + case 1: + { + setState(9676); + indirection(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Indirection_elContext extends ParserRuleContext { + public TerminalNode DOT() { return getToken(PostgreSqlParser.DOT, 0); } + public Attr_nameContext attr_name() { + return getRuleContext(Attr_nameContext.class,0); + } + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public TerminalNode OPEN_BRACKET() { return getToken(PostgreSqlParser.OPEN_BRACKET, 0); } + public TerminalNode CLOSE_BRACKET() { return getToken(PostgreSqlParser.CLOSE_BRACKET, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public List opt_slice_bound() { + return getRuleContexts(Opt_slice_boundContext.class); + } + public Opt_slice_boundContext opt_slice_bound(int i) { + return getRuleContext(Opt_slice_boundContext.class,i); + } + public TerminalNode COLON() { return getToken(PostgreSqlParser.COLON, 0); } + public Indirection_elContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indirection_el; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndirection_el(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndirection_el(this); + } + } + + public final Indirection_elContext indirection_el() throws RecognitionException { + Indirection_elContext _localctx = new Indirection_elContext(_ctx, getState()); + enterRule(_localctx, 1320, RULE_indirection_el); + try { + setState(9694); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: + enterOuterAlt(_localctx, 1); + { + setState(9679); + match(DOT); + setState(9682); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALL: + case ANALYSE: + case ANALYZE: + case AND: + case ANY: + case ARRAY: + case AS: + case ASC: + case ASYMMETRIC: + case BOTH: + case CASE: + case CAST: + case CHECK: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CREATE: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DEFERRABLE: + case DESC: + case DISTINCT: + case DO: + case ELSE: + case EXCEPT: + case FALSE_P: + case FETCH: + case FOR: + case FOREIGN: + case FROM: + case GRANT: + case GROUP_P: + case HAVING: + case IN_P: + case INITIALLY: + case INTERSECT: + case LATERAL_P: + case LEADING: + case LIMIT: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case OFFSET: + case ON: + case ONLY: + case OR: + case ORDER: + case PLACING: + case PRIMARY: + case REFERENCES: + case RETURNING: + case SELECT: + case SESSION_USER: + case SOME: + case SYMMETRIC: + case TABLE: + case THEN: + case TO: + case TRAILING: + case TRUE_P: + case UNION: + case UNIQUE: + case USER: + case USING: + case VARIADIC: + case WHEN: + case WHERE: + case WINDOW: + case WITH: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case END_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(9680); + attr_name(); + } + break; + case STAR: + { + setState(9681); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case OPEN_BRACKET: + enterOuterAlt(_localctx, 2); + { + setState(9684); + match(OPEN_BRACKET); + setState(9690); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,637,_ctx) ) { + case 1: + { + setState(9685); + a_expr(); + } + break; + case 2: + { + setState(9686); + opt_slice_bound(); + setState(9687); + match(COLON); + setState(9688); + opt_slice_bound(); + } + break; + } + setState(9692); + match(CLOSE_BRACKET); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_slice_boundContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Opt_slice_boundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_slice_bound; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_slice_bound(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_slice_bound(this); + } + } + + public final Opt_slice_boundContext opt_slice_bound() throws RecognitionException { + Opt_slice_boundContext _localctx = new Opt_slice_boundContext(_ctx, getState()); + enterRule(_localctx, 1322, RULE_opt_slice_bound); + try { + setState(9698); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,639,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9696); + a_expr(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IndirectionContext extends ParserRuleContext { + public List indirection_el() { + return getRuleContexts(Indirection_elContext.class); + } + public Indirection_elContext indirection_el(int i) { + return getRuleContext(Indirection_elContext.class,i); + } + public IndirectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indirection; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndirection(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndirection(this); + } + } + + public final IndirectionContext indirection() throws RecognitionException { + IndirectionContext _localctx = new IndirectionContext(_ctx, getState()); + enterRule(_localctx, 1324, RULE_indirection); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(9701); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(9700); + indirection_el(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(9703); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,640,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_indirectionContext extends ParserRuleContext { + public List indirection_el() { + return getRuleContexts(Indirection_elContext.class); + } + public Indirection_elContext indirection_el(int i) { + return getRuleContext(Indirection_elContext.class,i); + } + public Opt_indirectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_indirection; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_indirection(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_indirection(this); + } + } + + public final Opt_indirectionContext opt_indirection() throws RecognitionException { + Opt_indirectionContext _localctx = new Opt_indirectionContext(_ctx, getState()); + enterRule(_localctx, 1326, RULE_opt_indirection); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(9708); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,641,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(9705); + indirection_el(); + } + } + } + setState(9710); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,641,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_target_listContext extends ParserRuleContext { + public Target_listContext target_list() { + return getRuleContext(Target_listContext.class,0); + } + public Opt_target_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_target_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_target_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_target_list(this); + } + } + + public final Opt_target_listContext opt_target_list() throws RecognitionException { + Opt_target_listContext _localctx = new Opt_target_listContext(_ctx, getState()); + enterRule(_localctx, 1328, RULE_opt_target_list); + try { + setState(9713); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,642,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9711); + target_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Target_listContext extends ParserRuleContext { + public List target_el() { + return getRuleContexts(Target_elContext.class); + } + public Target_elContext target_el(int i) { + return getRuleContext(Target_elContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Target_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_target_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTarget_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTarget_list(this); + } + } + + public final Target_listContext target_list() throws RecognitionException { + Target_listContext _localctx = new Target_listContext(_ctx, getState()); + enterRule(_localctx, 1330, RULE_target_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(9715); + target_el(); + setState(9720); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,643,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(9716); + match(COMMA); + setState(9717); + target_el(); + } + } + } + setState(9722); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,643,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Target_elContext extends ParserRuleContext { + public Target_elContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_target_el; } + + public Target_elContext() { } + public void copyFrom(Target_elContext ctx) { + super.copyFrom(ctx); + } + } + @SuppressWarnings("CheckReturnValue") + public static class Target_labelContext extends Target_elContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Target_labelContext(Target_elContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTarget_label(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTarget_label(this); + } + } + @SuppressWarnings("CheckReturnValue") + public static class Target_starContext extends Target_elContext { + public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } + public Target_starContext(Target_elContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTarget_star(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTarget_star(this); + } + } + + public final Target_elContext target_el() throws RecognitionException { + Target_elContext _localctx = new Target_elContext(_ctx, getState()); + enterRule(_localctx, 1332, RULE_target_el); + try { + setState(9731); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case COLON: + case QUESTION: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNIQUE: + case USER: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + _localctx = new Target_labelContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(9723); + a_expr(); + setState(9728); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,644,_ctx) ) { + case 1: + { + setState(9724); + match(AS); + setState(9725); + collabel(); + } + break; + case 2: + { + setState(9726); + identifier(); + } + break; + case 3: + { + } + break; + } + } + break; + case STAR: + _localctx = new Target_starContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(9730); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Qualified_name_listContext extends ParserRuleContext { + public List qualified_name() { + return getRuleContexts(Qualified_nameContext.class); + } + public Qualified_nameContext qualified_name(int i) { + return getRuleContext(Qualified_nameContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Qualified_name_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualified_name_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterQualified_name_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitQualified_name_list(this); + } + } + + public final Qualified_name_listContext qualified_name_list() throws RecognitionException { + Qualified_name_listContext _localctx = new Qualified_name_listContext(_ctx, getState()); + enterRule(_localctx, 1334, RULE_qualified_name_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9733); + qualified_name(); + setState(9738); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(9734); + match(COMMA); + setState(9735); + qualified_name(); + } + } + setState(9740); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Qualified_nameContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public IndirectionContext indirection() { + return getRuleContext(IndirectionContext.class,0); + } + public Qualified_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualified_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterQualified_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitQualified_name(this); + } + } + + public final Qualified_nameContext qualified_name() throws RecognitionException { + Qualified_nameContext _localctx = new Qualified_nameContext(_ctx, getState()); + enterRule(_localctx, 1336, RULE_qualified_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9741); + colid(); + setState(9743); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_BRACKET || _la==DOT) { + { + setState(9742); + indirection(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Name_listContext extends ParserRuleContext { + public List name() { + return getRuleContexts(NameContext.class); + } + public NameContext name(int i) { + return getRuleContext(NameContext.class,i); } public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } public TerminalNode COMMA(int i) { @@ -43458,26 +84848,26 @@ public class PostgreSqlParser extends Parser { public final Name_listContext name_list() throws RecognitionException { Name_listContext _localctx = new Name_listContext(_ctx, getState()); - enterRule(_localctx, 474, RULE_name_list); + enterRule(_localctx, 1338, RULE_name_list); int _la; try { enterOuterAlt(_localctx, 1); { - setState(5175); - name_(); - setState(5180); + setState(9745); + name(); + setState(9750); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(5176); + setState(9746); match(COMMA); - setState(5177); - name_(); + setState(9747); + name(); } } - setState(5182); + setState(9752); _errHandler.sync(this); _la = _input.LA(1); } @@ -43495,58 +84885,32 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Identifier_listContext extends ParserRuleContext { - public List identifier() { - return getRuleContexts(IdentifierContext.class); + public static class NameContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Identifier_listContext(ParserRuleContext parent, int invokingState) { + public NameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_identifier_list; } + @Override public int getRuleIndex() { return RULE_name; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIdentifier_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterName(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIdentifier_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitName(this); } } - public final Identifier_listContext identifier_list() throws RecognitionException { - Identifier_listContext _localctx = new Identifier_listContext(_ctx, getState()); - enterRule(_localctx, 476, RULE_identifier_list); + public final NameContext name() throws RecognitionException { + NameContext _localctx = new NameContext(_ctx, getState()); + enterRule(_localctx, 1340, RULE_name); try { - int _alt; enterOuterAlt(_localctx, 1); { - setState(5183); - identifier(0); - setState(5188); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,617,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(5184); - match(COMMA); - setState(5185); - identifier(0); - } - } - } - setState(5190); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,617,_ctx); - } + setState(9753); + colid(); } } catch (RecognitionException re) { @@ -43561,51 +84925,32 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Option_exprContext extends ParserRuleContext { - public IdentifierContext option_name; - public Param_valueContext value; - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public static class Attr_nameContext extends ParserRuleContext { + public CollabelContext collabel() { + return getRuleContext(CollabelContext.class,0); } - public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } - public Param_valueContext param_value() { - return getRuleContext(Param_valueContext.class,0); - } - public Option_exprContext(ParserRuleContext parent, int invokingState) { + public Attr_nameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_option_expr; } + @Override public int getRuleIndex() { return RULE_attr_name; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOption_expr(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAttr_name(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOption_expr(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAttr_name(this); } } - public final Option_exprContext option_expr() throws RecognitionException { - Option_exprContext _localctx = new Option_exprContext(_ctx, getState()); - enterRule(_localctx, 478, RULE_option_expr); - int _la; + public final Attr_nameContext attr_name() throws RecognitionException { + Attr_nameContext _localctx = new Attr_nameContext(_ctx, getState()); + enterRule(_localctx, 1342, RULE_attr_name); try { enterOuterAlt(_localctx, 1); { - setState(5191); - ((Option_exprContext)_localctx).option_name = identifier(0); - setState(5194); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==EQUAL) { - { - setState(5192); - match(EQUAL); - setState(5193); - ((Option_exprContext)_localctx).value = param_value(); - } - } - + setState(9755); + collabel(); } } catch (RecognitionException re) { @@ -43620,884 +84965,32 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Option_listContext extends ParserRuleContext { - public List option_expr() { - return getRuleContexts(Option_exprContext.class); + public static class File_nameContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); } - public Option_exprContext option_expr(int i) { - return getRuleContext(Option_exprContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Option_listContext(ParserRuleContext parent, int invokingState) { + public File_nameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_option_list; } + @Override public int getRuleIndex() { return RULE_file_name; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOption_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFile_name(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOption_list(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFile_name(this); } } - public final Option_listContext option_list() throws RecognitionException { - Option_listContext _localctx = new Option_listContext(_ctx, getState()); - enterRule(_localctx, 480, RULE_option_list); - int _la; + public final File_nameContext file_name() throws RecognitionException { + File_nameContext _localctx = new File_nameContext(_ctx, getState()); + enterRule(_localctx, 1344, RULE_file_name); try { enterOuterAlt(_localctx, 1); { - setState(5196); - option_expr(); - setState(5201); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5197); - match(COMMA); - setState(5198); - option_expr(); - } - } - setState(5203); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Table_name_Context extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Table_name_Context(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_table_name_; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTable_name_(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTable_name_(this); - } - } - - public final Table_name_Context table_name_() throws RecognitionException { - Table_name_Context _localctx = new Table_name_Context(_ctx, getState()); - enterRule(_localctx, 482, RULE_table_name_); - try { - enterOuterAlt(_localctx, 1); - { - setState(5204); - identifier(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Data_typeContext extends ParserRuleContext { - public Type_nameContext type_name() { - return getRuleContext(Type_nameContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public List OPEN_BRACKET() { return getTokens(PostgreSqlParser.OPEN_BRACKET); } - public TerminalNode OPEN_BRACKET(int i) { - return getToken(PostgreSqlParser.OPEN_BRACKET, i); - } - public List CLOSE_BRACKET() { return getTokens(PostgreSqlParser.CLOSE_BRACKET); } - public TerminalNode CLOSE_BRACKET(int i) { - return getToken(PostgreSqlParser.CLOSE_BRACKET, i); - } - public List INTEGER_LITERAL() { return getTokens(PostgreSqlParser.INTEGER_LITERAL); } - public TerminalNode INTEGER_LITERAL(int i) { - return getToken(PostgreSqlParser.INTEGER_LITERAL, i); - } - public Data_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_data_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterData_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitData_type(this); - } - } - - public final Data_typeContext data_type() throws RecognitionException { - Data_typeContext _localctx = new Data_typeContext(_ctx, getState()); - enterRule(_localctx, 484, RULE_data_type); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(5208); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,620,_ctx) ) { - case 1: - { - setState(5206); - type_name(); - } - break; - case 2: - { - setState(5207); - identifier(0); - } - break; - } - setState(5217); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,622,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(5210); - match(OPEN_BRACKET); - setState(5212); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INTEGER_LITERAL) { - { - setState(5211); - match(INTEGER_LITERAL); - } - } - - setState(5214); - match(CLOSE_BRACKET); - } - } - } - setState(5219); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,622,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Data_type_listContext extends ParserRuleContext { - public List data_type() { - return getRuleContexts(Data_typeContext.class); - } - public Data_typeContext data_type(int i) { - return getRuleContext(Data_typeContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Data_type_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_data_type_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterData_type_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitData_type_list(this); - } - } - - public final Data_type_listContext data_type_list() throws RecognitionException { - Data_type_listContext _localctx = new Data_type_listContext(_ctx, getState()); - enterRule(_localctx, 486, RULE_data_type_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(5220); - data_type(); - setState(5225); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5221); - match(COMMA); - setState(5222); - data_type(); - } - } - setState(5227); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Index_methodContext extends ParserRuleContext { - public Token builtin; - public IdentifierContext unknown; - public TerminalNode BTREE() { return getToken(PostgreSqlParser.BTREE, 0); } - public TerminalNode HASH_() { return getToken(PostgreSqlParser.HASH_, 0); } - public TerminalNode GIST() { return getToken(PostgreSqlParser.GIST, 0); } - public TerminalNode SPGIST() { return getToken(PostgreSqlParser.SPGIST, 0); } - public TerminalNode GIN() { return getToken(PostgreSqlParser.GIN, 0); } - public TerminalNode BRIN() { return getToken(PostgreSqlParser.BRIN, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Index_methodContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_index_method; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndex_method(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndex_method(this); - } - } - - public final Index_methodContext index_method() throws RecognitionException { - Index_methodContext _localctx = new Index_methodContext(_ctx, getState()); - enterRule(_localctx, 488, RULE_index_method); - int _la; - try { - setState(5230); - _errHandler.sync(this); - switch (_input.LA(1)) { - case BTREE: - case HASH_: - case GIST: - case SPGIST: - case GIN: - case BRIN: - enterOuterAlt(_localctx, 1); - { - setState(5228); - ((Index_methodContext)_localctx).builtin = _input.LT(1); - _la = _input.LA(1); - if ( !(((((_la - 703)) & ~0x3f) == 0 && ((1L << (_la - 703)) & 63L) != 0)) ) { - ((Index_methodContext)_localctx).builtin = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - break; - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - enterOuterAlt(_localctx, 2); - { - setState(5229); - ((Index_methodContext)_localctx).unknown = identifier(0); - } - break; - default: - throw new NoViableAltException(this); + setState(9757); + sconst(); } } catch (RecognitionException re) { @@ -44513,9 +85006,20 @@ public class PostgreSqlParser extends Parser { @SuppressWarnings("CheckReturnValue") public static class Func_nameContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public Builtin_function_nameContext builtin_function_name() { + return getRuleContext(Builtin_function_nameContext.class,0); } + public Type_function_nameContext type_function_name() { + return getRuleContext(Type_function_nameContext.class,0); + } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public IndirectionContext indirection() { + return getRuleContext(IndirectionContext.class,0); + } + public TerminalNode LEFT() { return getToken(PostgreSqlParser.LEFT, 0); } + public TerminalNode RIGHT() { return getToken(PostgreSqlParser.RIGHT, 0); } public Func_nameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -44532,12 +85036,48 @@ public class PostgreSqlParser extends Parser { public final Func_nameContext func_name() throws RecognitionException { Func_nameContext _localctx = new Func_nameContext(_ctx, getState()); - enterRule(_localctx, 490, RULE_func_name); + enterRule(_localctx, 1346, RULE_func_name); try { - enterOuterAlt(_localctx, 1); - { - setState(5232); - identifier(0); + setState(9766); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,649,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9759); + builtin_function_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9760); + type_function_name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9761); + colid(); + setState(9762); + indirection(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9764); + match(LEFT); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(9765); + match(RIGHT); + } + break; } } catch (RecognitionException re) { @@ -44552,2848 +85092,201 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Func_callContext extends ParserRuleContext { + public static class AexprconstContext extends ParserRuleContext { + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public FconstContext fconst() { + return getRuleContext(FconstContext.class,0); + } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public BconstContext bconst() { + return getRuleContext(BconstContext.class,0); + } + public XconstContext xconst() { + return getRuleContext(XconstContext.class,0); + } public Func_nameContext func_name() { return getRuleContext(Func_nameContext.class,0); } public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public TerminalNode VARIADIC() { return getToken(PostgreSqlParser.VARIADIC, 0); } - public List expr() { - return getRuleContexts(ExprContext.class); + public Func_arg_listContext func_arg_list() { + return getRuleContext(Func_arg_listContext.class,0); } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); + public Opt_sort_clauseContext opt_sort_clause() { + return getRuleContext(Opt_sort_clauseContext.class,0); } public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); + public ConsttypenameContext consttypename() { + return getRuleContext(ConsttypenameContext.class,0); } - public Todo_fill_inContext todo_fill_in() { - return getRuleContext(Todo_fill_inContext.class,0); + public ConstintervalContext constinterval() { + return getRuleContext(ConstintervalContext.class,0); } - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } - public Func_callContext(ParserRuleContext parent, int invokingState) { + public Opt_intervalContext opt_interval() { + return getRuleContext(Opt_intervalContext.class,0); + } + public TerminalNode TRUE_P() { return getToken(PostgreSqlParser.TRUE_P, 0); } + public TerminalNode FALSE_P() { return getToken(PostgreSqlParser.FALSE_P, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public AexprconstContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_func_call; } + @Override public int getRuleIndex() { return RULE_aexprconst; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_call(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAexprconst(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_call(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAexprconst(this); } } - public final Func_callContext func_call() throws RecognitionException { - Func_callContext _localctx = new Func_callContext(_ctx, getState()); - enterRule(_localctx, 492, RULE_func_call); - int _la; + public final AexprconstContext aexprconst() throws RecognitionException { + AexprconstContext _localctx = new AexprconstContext(_ctx, getState()); + enterRule(_localctx, 1348, RULE_aexprconst); try { - int _alt; - setState(5270); + setState(9800); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,629,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,652,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(5234); - func_name(); - setState(5235); - match(OPEN_PAREN); - setState(5236); - match(VARIADIC); - setState(5237); - expr(0); - setState(5238); - match(CLOSE_PAREN); + setState(9768); + iconst(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(5240); - func_name(); - setState(5241); - match(OPEN_PAREN); - setState(5255); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -11575800568512526L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334777102337L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245452583049L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206567384408260611L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & -6102417216219643909L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 4537576733544546303L) != 0) || ((((_la - 788)) & ~0x3f) == 0 && ((1L << (_la - 788)) & 1262854602757L) != 0)) { - { - setState(5242); - expr(0); - setState(5247); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,625,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(5243); - match(COMMA); - setState(5244); - expr(0); - } - } - } - setState(5249); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,625,_ctx); - } - setState(5253); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(5250); - match(COMMA); - setState(5251); - match(VARIADIC); - setState(5252); - expr(0); - } - } - - } - } - - setState(5257); - match(CLOSE_PAREN); + setState(9769); + fconst(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(5259); - func_name(); - setState(5260); - match(OPEN_PAREN); - setState(5261); - todo_fill_in(); - setState(5262); - match(FROM); - setState(5263); - expr(0); - setState(5266); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FOR) { - { - setState(5264); - match(FOR); - setState(5265); - expr(0); - } - } - - setState(5268); - match(CLOSE_PAREN); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Array_cons_exprContext extends ParserRuleContext { - public TerminalNode ARRAY() { return getToken(PostgreSqlParser.ARRAY, 0); } - public TerminalNode OPEN_BRACKET() { return getToken(PostgreSqlParser.OPEN_BRACKET, 0); } - public TerminalNode CLOSE_BRACKET() { return getToken(PostgreSqlParser.CLOSE_BRACKET, 0); } - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Array_cons_exprContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_array_cons_expr; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterArray_cons_expr(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitArray_cons_expr(this); - } - } - - public final Array_cons_exprContext array_cons_expr() throws RecognitionException { - Array_cons_exprContext _localctx = new Array_cons_exprContext(_ctx, getState()); - enterRule(_localctx, 494, RULE_array_cons_expr); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(5272); - match(ARRAY); - setState(5273); - match(OPEN_BRACKET); - setState(5282); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -11575800568512526L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334777102337L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245452583049L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206567384408260611L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & -6102417216219643909L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || ((((_la - 721)) & ~0x3f) == 0 && ((1L << (_la - 721)) & 4537576733544546303L) != 0) || ((((_la - 788)) & ~0x3f) == 0 && ((1L << (_la - 788)) & 1262854602757L) != 0)) { - { - setState(5274); - expr(0); - setState(5279); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5275); - match(COMMA); - setState(5276); - expr(0); - } - } - setState(5281); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(5284); - match(CLOSE_BRACKET); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class From_itemContext extends ParserRuleContext { - public Table_name_Context table_name_() { - return getRuleContext(Table_name_Context.class,0); - } - public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public With_column_aliasContext with_column_alias() { - return getRuleContext(With_column_aliasContext.class,0); - } - public TerminalNode TABLESAMPLE() { return getToken(PostgreSqlParser.TABLESAMPLE, 0); } - public List todo_fill_in() { - return getRuleContexts(Todo_fill_inContext.class); - } - public Todo_fill_inContext todo_fill_in(int i) { - return getRuleContext(Todo_fill_inContext.class,i); - } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public TerminalNode REPEATABLE() { return getToken(PostgreSqlParser.REPEATABLE, 0); } - public StmtContext stmt() { - return getRuleContext(StmtContext.class,0); - } - public AliasContext alias() { - return getRuleContext(AliasContext.class,0); - } - public TerminalNode LATERAL() { return getToken(PostgreSqlParser.LATERAL, 0); } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public List column_alias() { - return getRuleContexts(Column_aliasContext.class); - } - public Column_aliasContext column_alias(int i) { - return getRuleContext(Column_aliasContext.class,i); - } - public Func_callContext func_call() { - return getRuleContext(Func_callContext.class,0); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode ORDINALITY() { return getToken(PostgreSqlParser.ORDINALITY, 0); } - public List column_definition() { - return getRuleContexts(Column_definitionContext.class); - } - public Column_definitionContext column_definition(int i) { - return getRuleContext(Column_definitionContext.class,i); - } - public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } - public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public List from_item() { - return getRuleContexts(From_itemContext.class); - } - public From_itemContext from_item(int i) { - return getRuleContext(From_itemContext.class,i); - } - public Join_typeContext join_type() { - return getRuleContext(Join_typeContext.class,0); - } - public TerminalNode NATURAL() { return getToken(PostgreSqlParser.NATURAL, 0); } - public Join_clauseContext join_clause() { - return getRuleContext(Join_clauseContext.class,0); - } - public From_itemContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_from_item; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrom_item(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrom_item(this); - } - } - - public final From_itemContext from_item() throws RecognitionException { - return from_item(0); - } - - private From_itemContext from_item(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - From_itemContext _localctx = new From_itemContext(_ctx, _parentState); - From_itemContext _prevctx = _localctx; - int _startState = 496; - enterRecursionRule(_localctx, 496, RULE_from_item, _p); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(5392); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,650,_ctx) ) { - case 1: - { - setState(5288); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ONLY) { - { - setState(5287); - match(ONLY); - } - } - - setState(5290); - table_name_(); - setState(5292); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,633,_ctx) ) { - case 1: - { - setState(5291); - match(STAR); - } - break; - } - setState(5295); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,634,_ctx) ) { - case 1: - { - setState(5294); - with_column_alias(); - } - break; - } - setState(5316); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,637,_ctx) ) { - case 1: - { - setState(5297); - match(TABLESAMPLE); - setState(5298); - todo_fill_in(); - setState(5299); - match(OPEN_PAREN); - setState(5300); - expr(0); - setState(5305); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5301); - match(COMMA); - setState(5302); - expr(0); - } - } - setState(5307); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(5308); - match(CLOSE_PAREN); - setState(5314); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,636,_ctx) ) { - case 1: - { - setState(5309); - match(REPEATABLE); - setState(5310); - match(OPEN_PAREN); - setState(5311); - todo_fill_in(); - setState(5312); - match(CLOSE_PAREN); - } - break; - } - } - break; - } - } - break; - case 2: - { - setState(5319); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LATERAL) { - { - setState(5318); - match(LATERAL); - } - } - - setState(5321); - match(OPEN_PAREN); - setState(5322); - stmt(); - setState(5323); - match(CLOSE_PAREN); - setState(5325); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(5324); - match(AS); - } - } - - setState(5327); - alias(); - setState(5339); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,641,_ctx) ) { - case 1: - { - setState(5328); - match(OPEN_PAREN); - setState(5329); - column_alias(); - setState(5334); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5330); - match(COMMA); - setState(5331); - column_alias(); - } - } - setState(5336); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(5337); - match(CLOSE_PAREN); - } - break; - } - } - break; - case 3: - { - setState(5342); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LATERAL) { - { - setState(5341); - match(LATERAL); - } - } - - setState(5344); - func_call(); - setState(5347); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,643,_ctx) ) { - case 1: - { - setState(5345); - match(WITH); - setState(5346); - match(ORDINALITY); - } - break; - } - setState(5350); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,644,_ctx) ) { - case 1: - { - setState(5349); - with_column_alias(); - } - break; - } - } - break; - case 4: - { - setState(5353); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LATERAL) { - { - setState(5352); - match(LATERAL); - } - } - - setState(5355); - func_call(); - setState(5356); - match(AS); - setState(5357); - match(OPEN_PAREN); - setState(5358); - column_definition(); - setState(5363); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5359); - match(COMMA); - setState(5360); - column_definition(); - } - } - setState(5365); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(5366); - match(CLOSE_PAREN); - } - break; - case 5: - { - setState(5369); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LATERAL) { - { - setState(5368); - match(LATERAL); - } - } - - setState(5371); - match(ROWS); - setState(5372); - match(FROM); - setState(5373); - match(OPEN_PAREN); - setState(5374); - func_call(); - setState(5375); - match(CLOSE_PAREN); - setState(5388); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(5376); - match(AS); - setState(5377); - match(OPEN_PAREN); - setState(5378); - column_definition(); - setState(5383); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5379); - match(COMMA); - setState(5380); - column_definition(); - } - } - setState(5385); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(5386); - match(CLOSE_PAREN); - } - } - - setState(5390); - match(CLOSE_PAREN); - } - break; - } - _ctx.stop = _input.LT(-1); - setState(5411); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,655,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - if ( _parseListeners!=null ) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new From_itemContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_from_item); - setState(5394); - if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); - setState(5396); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NATURAL) { - { - setState(5395); - match(NATURAL); - } - } - - setState(5398); - join_type(); - setState(5400); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,652,_ctx) ) { - case 1: - { - setState(5399); - match(OPEN_PAREN); - } - break; - } - setState(5402); - from_item(0); - setState(5404); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,653,_ctx) ) { - case 1: - { - setState(5403); - join_clause(); - } - break; - } - setState(5407); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,654,_ctx) ) { - case 1: - { - setState(5406); - match(CLOSE_PAREN); - } - break; - } - } - } - } - setState(5413); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,655,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class With_column_aliasContext extends ParserRuleContext { - public AliasContext alias() { - return getRuleContext(AliasContext.class,0); - } - public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } - public List column_alias() { - return getRuleContexts(Column_aliasContext.class); - } - public Column_aliasContext column_alias(int i) { - return getRuleContext(Column_aliasContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Name_listContext name_list() { - return getRuleContext(Name_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public With_column_aliasContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_with_column_alias; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWith_column_alias(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWith_column_alias(this); - } - } - - public final With_column_aliasContext with_column_alias() throws RecognitionException { - With_column_aliasContext _localctx = new With_column_aliasContext(_ctx, getState()); - enterRule(_localctx, 498, RULE_with_column_alias); - int _la; - try { - int _alt; - setState(5436); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,660,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(5415); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(5414); - match(AS); - } - } - - setState(5417); - alias(); - setState(5426); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,658,_ctx) ) { - case 1: - { - setState(5418); - column_alias(); - setState(5423); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,657,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(5419); - match(COMMA); - setState(5420); - column_alias(); - } - } - } - setState(5425); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,657,_ctx); - } - } - break; - } - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(5429); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AS) { - { - setState(5428); - match(AS); - } - } - - setState(5431); - alias(); - setState(5432); - match(OPEN_PAREN); - setState(5433); - name_list(); - setState(5434); - match(CLOSE_PAREN); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Join_typeContext extends ParserRuleContext { - public TerminalNode JOIN() { return getToken(PostgreSqlParser.JOIN, 0); } - public TerminalNode INNER() { return getToken(PostgreSqlParser.INNER, 0); } - public TerminalNode LEFT() { return getToken(PostgreSqlParser.LEFT, 0); } - public TerminalNode OUTER() { return getToken(PostgreSqlParser.OUTER, 0); } - public TerminalNode RIGHT() { return getToken(PostgreSqlParser.RIGHT, 0); } - public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } - public TerminalNode CROSS() { return getToken(PostgreSqlParser.CROSS, 0); } - public Join_typeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_join_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterJoin_type(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitJoin_type(this); - } - } - - public final Join_typeContext join_type() throws RecognitionException { - Join_typeContext _localctx = new Join_typeContext(_ctx, getState()); - enterRule(_localctx, 500, RULE_join_type); - int _la; - try { - setState(5459); - _errHandler.sync(this); - switch (_input.LA(1)) { - case INNER: - case JOIN: - enterOuterAlt(_localctx, 1); - { - setState(5439); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INNER) { - { - setState(5438); - match(INNER); - } - } - - setState(5441); - match(JOIN); - } - break; - case LEFT: - enterOuterAlt(_localctx, 2); - { - setState(5442); - match(LEFT); - setState(5444); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OUTER) { - { - setState(5443); - match(OUTER); - } - } - - setState(5446); - match(JOIN); - } - break; - case RIGHT: - enterOuterAlt(_localctx, 3); - { - setState(5447); - match(RIGHT); - setState(5449); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OUTER) { - { - setState(5448); - match(OUTER); - } - } - - setState(5451); - match(JOIN); - } - break; - case FULL: - enterOuterAlt(_localctx, 4); - { - setState(5452); - match(FULL); - setState(5454); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==OUTER) { - { - setState(5453); - match(OUTER); - } - } - - setState(5456); - match(JOIN); - } - break; - case CROSS: - enterOuterAlt(_localctx, 5); - { - setState(5457); - match(CROSS); - setState(5458); - match(JOIN); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Join_clauseContext extends ParserRuleContext { - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public PredicateContext predicate() { - return getRuleContext(PredicateContext.class,0); - } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List column_name() { - return getRuleContexts(Column_nameContext.class); - } - public Column_nameContext column_name(int i) { - return getRuleContext(Column_nameContext.class,i); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Join_clauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_join_clause; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterJoin_clause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitJoin_clause(this); - } - } - - public final Join_clauseContext join_clause() throws RecognitionException { - Join_clauseContext _localctx = new Join_clauseContext(_ctx, getState()); - enterRule(_localctx, 502, RULE_join_clause); - int _la; - try { - setState(5475); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ON: - enterOuterAlt(_localctx, 1); - { - setState(5461); - match(ON); - setState(5462); - predicate(0); - } - break; - case USING: - enterOuterAlt(_localctx, 2); - { - setState(5463); - match(USING); - setState(5464); - match(OPEN_PAREN); - setState(5465); - column_name(); - setState(5470); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5466); - match(COMMA); - setState(5467); - column_name(); - } - } - setState(5472); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(5473); - match(CLOSE_PAREN); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class PredicateContext extends ParserRuleContext { - public List expr() { - return getRuleContexts(ExprContext.class); - } - public ExprContext expr(int i) { - return getRuleContext(ExprContext.class,i); - } - public OperContext oper() { - return getRuleContext(OperContext.class,0); - } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public List predicate() { - return getRuleContexts(PredicateContext.class); - } - public PredicateContext predicate(int i) { - return getRuleContext(PredicateContext.class,i); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } - public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } - public PredicateContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_predicate; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPredicate(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPredicate(this); - } - } - - public final PredicateContext predicate() throws RecognitionException { - return predicate(0); - } - - private PredicateContext predicate(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - PredicateContext _localctx = new PredicateContext(_ctx, _parentState); - PredicateContext _prevctx = _localctx; - int _startState = 504; - enterRecursionRule(_localctx, 504, RULE_predicate, _p); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(5489); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,668,_ctx) ) { - case 1: - { - setState(5478); - expr(0); - } - break; - case 2: - { - setState(5479); - expr(0); - setState(5480); - oper(); - setState(5481); - expr(0); - } - break; - case 3: - { - setState(5483); - match(OPEN_PAREN); - setState(5484); - predicate(0); - setState(5485); - match(CLOSE_PAREN); - } - break; - case 4: - { - setState(5487); - match(NOT); - setState(5488); - predicate(1); - } - break; - } - _ctx.stop = _input.LT(-1); - setState(5499); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,670,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - if ( _parseListeners!=null ) triggerExitRuleEvent(); - _prevctx = _localctx; - { - setState(5497); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,669,_ctx) ) { - case 1: - { - _localctx = new PredicateContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_predicate); - setState(5491); - if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(5492); - match(AND); - setState(5493); - predicate(4); - } - break; - case 2: - { - _localctx = new PredicateContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_predicate); - setState(5494); - if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(5495); - match(OR); - setState(5496); - predicate(3); - } - break; - } - } - } - setState(5501); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,670,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Aggregate_signatureContext extends ParserRuleContext { - public Token argmode; - public IdentifierContext argname; - public Data_type_listContext argtype; - public TerminalNode STAR() { return getToken(PostgreSqlParser.STAR, 0); } - public List data_type_list() { - return getRuleContexts(Data_type_listContext.class); - } - public Data_type_listContext data_type_list(int i) { - return getRuleContext(Data_type_listContext.class,i); - } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public List IN() { return getTokens(PostgreSqlParser.IN); } - public TerminalNode IN(int i) { - return getToken(PostgreSqlParser.IN, i); - } - public List VARIADIC() { return getTokens(PostgreSqlParser.VARIADIC); } - public TerminalNode VARIADIC(int i) { - return getToken(PostgreSqlParser.VARIADIC, i); - } - public TerminalNode ORDER() { return getToken(PostgreSqlParser.ORDER, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public Aggregate_signatureContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_aggregate_signature; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAggregate_signature(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAggregate_signature(this); - } - } - - public final Aggregate_signatureContext aggregate_signature() throws RecognitionException { - Aggregate_signatureContext _localctx = new Aggregate_signatureContext(_ctx, getState()); - enterRule(_localctx, 506, RULE_aggregate_signature); - int _la; - try { - setState(5528); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,677,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(5502); - match(STAR); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(5504); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN || _la==VARIADIC) { - { - setState(5503); - ((Aggregate_signatureContext)_localctx).argmode = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==IN || _la==VARIADIC) ) { - ((Aggregate_signatureContext)_localctx).argmode = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(5507); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,672,_ctx) ) { - case 1: - { - setState(5506); - ((Aggregate_signatureContext)_localctx).argname = identifier(0); - } - break; - } - setState(5509); - ((Aggregate_signatureContext)_localctx).argtype = data_type_list(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - { - setState(5511); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN || _la==VARIADIC) { - { - setState(5510); - ((Aggregate_signatureContext)_localctx).argmode = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==IN || _la==VARIADIC) ) { - ((Aggregate_signatureContext)_localctx).argmode = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(5514); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,674,_ctx) ) { - case 1: - { - setState(5513); - ((Aggregate_signatureContext)_localctx).argname = identifier(0); - } - break; - } - setState(5516); - ((Aggregate_signatureContext)_localctx).argtype = data_type_list(); - } - setState(5518); - match(ORDER); - setState(5519); - match(BY); - setState(5521); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==IN || _la==VARIADIC) { - { - setState(5520); - ((Aggregate_signatureContext)_localctx).argmode = _input.LT(1); - _la = _input.LA(1); - if ( !(_la==IN || _la==VARIADIC) ) { - ((Aggregate_signatureContext)_localctx).argmode = (Token)_errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(5524); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,676,_ctx) ) { - case 1: - { - setState(5523); - ((Aggregate_signatureContext)_localctx).argname = identifier(0); - } - break; - } - setState(5526); - ((Aggregate_signatureContext)_localctx).argtype = data_type_list(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Column_constraintContext extends ParserRuleContext { - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode NULL() { return getToken(PostgreSqlParser.NULL, 0); } - public Column_constraintContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_column_constraint; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_constraint(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_constraint(this); - } - } - - public final Column_constraintContext column_constraint() throws RecognitionException { - Column_constraintContext _localctx = new Column_constraintContext(_ctx, getState()); - enterRule(_localctx, 508, RULE_column_constraint); - try { - enterOuterAlt(_localctx, 1); - { - setState(5530); - match(NOT); - setState(5531); - match(NULL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Column_constraintsContext extends ParserRuleContext { - public List column_constraint() { - return getRuleContexts(Column_constraintContext.class); - } - public Column_constraintContext column_constraint(int i) { - return getRuleContext(Column_constraintContext.class,i); - } - public Column_constraintsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_column_constraints; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_constraints(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_constraints(this); - } - } - - public final Column_constraintsContext column_constraints() throws RecognitionException { - Column_constraintsContext _localctx = new Column_constraintsContext(_ctx, getState()); - enterRule(_localctx, 510, RULE_column_constraints); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(5534); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(5533); - column_constraint(); - } - } - setState(5536); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==NOT ); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Index_parametersContext extends ParserRuleContext { - public IdentifierContext tablespace; - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public Option_listContext option_list() { - return getRuleContext(Option_listContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } - public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Index_parametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_index_parameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIndex_parameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIndex_parameters(this); - } - } - - public final Index_parametersContext index_parameters() throws RecognitionException { - Index_parametersContext _localctx = new Index_parametersContext(_ctx, getState()); - enterRule(_localctx, 512, RULE_index_parameters); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(5543); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WITH) { - { - setState(5538); - match(WITH); - setState(5539); - match(OPEN_PAREN); - setState(5540); - option_list(); - setState(5541); - match(CLOSE_PAREN); - } - } - - setState(5549); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==USING) { - { - setState(5545); - match(USING); - setState(5546); - match(INDEX); - setState(5547); - match(TABLESPACE); - setState(5548); - ((Index_parametersContext)_localctx).tablespace = identifier(0); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Exclude_elementContext extends ParserRuleContext { - public IdentifierContext column_name_; - public IdentifierContext opclass; - public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public ExprContext expr() { - return getRuleContext(ExprContext.class,0); - } - public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode NULLS() { return getToken(PostgreSqlParser.NULLS, 0); } - public TerminalNode ASC() { return getToken(PostgreSqlParser.ASC, 0); } - public TerminalNode DESC() { return getToken(PostgreSqlParser.DESC, 0); } - public TerminalNode FIRST() { return getToken(PostgreSqlParser.FIRST, 0); } - public TerminalNode LAST() { return getToken(PostgreSqlParser.LAST, 0); } - public Exclude_elementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_exclude_element; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExclude_element(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExclude_element(this); - } - } - - public final Exclude_elementContext exclude_element() throws RecognitionException { - Exclude_elementContext _localctx = new Exclude_elementContext(_ctx, getState()); - enterRule(_localctx, 514, RULE_exclude_element); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(5556); - _errHandler.sync(this); - switch (_input.LA(1)) { - case WHITESPACE: - case A_: - case ABORT: - case ABS: - case ABSOLUTE: - case ACCESS: - case ACTION: - case ADA: - case ADD: - case ADMIN: - case AFTER: - case AGGREGATE: - case ALLOCATE: - case ALSO: - case ALTER: - case ALWAYS: - case ANY: - case ARE: - case ASENSITIVE: - case ASSERTION: - case ASSIGNMENT: - case AT: - case ATOMIC: - case ATTRIBUTE: - case ATTRIBUTES: - case AVG: - case BACKWARD: - case BEFORE: - case BEGIN: - case BERNOULLI: - case BETWEEN: - case BIGINT: - case BIT: - case BIT_LENGTH: - case BLOB: - case BOOLEAN: - case BREADTH: - case BY: - case C_: - case CACHE: - case CALL: - case CALLED: - case CARDINALITY: - case CASCADE: - case CASCADED: - case CATALOG: - case CATALOG_NAME: - case CEIL: - case CEILING: - case CHAIN: - case CHAR: - case CHAR_LENGTH: - case CHARACTER: - case CHARACTER_LENGTH: - case CHARACTER_SET_CATALOG: - case CHARACTER_SET_NAME: - case CHARACTER_SET_SCHEMA: - case CHARACTERISTICS: - case CHARACTERS: - case CHECKPOINT: - case CLASS: - case CLASS_ORIGIN: - case CLOB: - case CLOSE: - case CLUSTER: - case COALESCE: - case COBOL: - case COLLATION_CATALOG: - case COLLATION_NAME: - case COLLATION_SCHEMA: - case COLLECT: - case COLUMN_NAME: - case COMMAND_FUNCTION: - case COMMAND_FUNCTION_CODE: - case COMMENT: - case COMMIT: - case COMMITTED: - case CONDITION: - case CONDITION_NUMBER: - case CONNECT: - case CONNECTION: - case CONNECTION_NAME: - case CONSTRAINT_CATALOG: - case CONSTRAINT_NAME: - case CONSTRAINT_SCHEMA: - case CONSTRAINTS: - case CONSTRUCTOR: - case CONTAINS: - case CONTINUE: - case CONVERSION: - case CONVERT: - case COPY: - case CORR: - case CORRESPONDING: - case COUNT: - case COVAR_POP: - case COVAR_SAMP: - case CSV: - case CUBE: - case CUME_DIST: - case CURRENT: - case CURRENT_DEFAULT_TRANSFORM_GROUP: - case CURRENT_PATH: - case CURRENT_TRANSFORM_GROUP_FOR_TYPE: - case CURSOR: - case CURSOR_NAME: - case CYCLE: - case DATA: - case DATABASE: - case DATE: - case DATETIME_INTERVAL_CODE: - case DATETIME_INTERVAL_PRECISION: - case DAY: - case DEALLOCATE: - case DEC: - case DECIMAL: - case DECLARE: - case DEFAULTS: - case DEFERRED: - case DEFINED: - case DEFINER: - case DEGREE: - case DELETE: - case DELIMITER: - case DELIMITERS: - case DENSE_RANK: - case DEPTH: - case DEREF: - case DERIVED: - case DESCRIBE: - case DESCRIPTOR: - case DETERMINISTIC: - case DIAGNOSTICS: - case DICTIONARY: - case DISCONNECT: - case DISPATCH: - case DOMAIN: - case DOUBLE: - case DYNAMIC: - case DYNAMIC_FUNCTION: - case DYNAMIC_FUNCTION_CODE: - case EACH: - case ELEMENT: - case ENCODING: - case ENCRYPTED: - case END: - case EQUALS: - case ESCAPE: - case EVERY: - case EXCEPTION: - case EXCLUDE: - case EXCLUDING: - case EXCLUSIVE: - case EXEC: - case EXECUTE: - case EXISTS: - case EXP: - case EXPLAIN: - case EXTENSION: - case EXTERNAL: - case EXTRACT: - case FILTER: - case FINAL: - case FIRST: - case FLOAT: - case FLOOR: - case FOLLOWING: - case FORCE: - case FORMAT: - case FORTRAN: - case FORWARD: - case FOUND: - case FREE: - case FUNCTION: - case FUSION: - case G_: - case GENERAL: - case GENERATED: - case GET: - case GLOBAL: - case GO: - case GOTO: - case GRANTED: - case GREATEST: - case GROUPING: - case HANDLER: - case HIERARCHY: - case HOLD: - case HOST: - case HOUR: - case IDENTITY: - case IGNORE: - case IMMEDIATE: - case IMMUTABLE: - case IMPLEMENTATION: - case IMPLICIT: - case INCLUDING: - case INCREMENT: - case INDEX: - case INDICATOR: - case INHERITS: - case INOUT: - case INPUT: - case INSENSITIVE: - case INSERT: - case INSTANCE: - case INSTANTIABLE: - case INSTEAD: - case INT: - case INTEGER: - case INTERSECTION: - case INTERVAL: - case INVOKER: - case ISOLATION: - case K_: - case KEY: - case KEY_MEMBER: - case KEY_TYPE: - case LANGUAGE: - case LARGE: - case LAST: - case LEAST: - case LEFT: - case LENGTH: - case LEVEL: - case LISTEN: - case LN: - case LOAD: - case LOCAL: - case LOCATION: - case LOCATOR: - case LOCK: - case LOCKED: - case LOWER: - case M_: - case MAP: - case MATCH: - case MATCHED: - case MAX: - case MAXVALUE: - case MEMBER: - case MERGE: - case MESSAGE_LENGTH: - case MESSAGE_OCTET_LENGTH: - case MESSAGE_TEXT: - case METHOD: - case MIN: - case MINUTE: - case MINVALUE: - case MOD: - case MODE: - case MODIFIES: - case MODULE: - case MONTH: - case MORE_: - case MOVE: - case MULTISET: - case MUMPS: - case NAME: - case NAMES: - case NATIONAL: - case NCHAR: - case NCLOB: - case NESTING: - case NEW: - case NEXT: - case NO: - case NONE: - case NORMALIZE: - case NORMALIZED: - case NOTHING: - case NOTIFY: - case NOWAIT: - case NULLABLE: - case NULLIF: - case NULLS: - case NUMBER: - case NUMERIC: - case OBJECT: - case OCTET_LENGTH: - case OCTETS: - case OF: - case OFF: - case OIDS: - case OLD: - case OPEN: - case OPERATOR: - case OPTION: - case OPTIONS: - case ORDERING: - case ORDINALITY: - case OTHERS: - case OUT: - case OUTPUT: - case OVER: - case OVERLAY: - case OVERRIDING: - case OWNER: - case PAD: - case PARAMETER: - case PARAMETER_MODE: - case PARAMETER_NAME: - case PARAMETER_ORDINAL_POSITION: - case PARAMETER_SPECIFIC_CATALOG: - case PARAMETER_SPECIFIC_NAME: - case PARAMETER_SPECIFIC_SCHEMA: - case PARTIAL: - case PARTITION: - case PASCAL: - case PASSWORD: - case PATH: - case PERCENT_RANK: - case PERCENTILE_CONT: - case PERCENTILE_DISC: - case PLAIN: - case PLI: - case POSITION: - case POWER: - case PRECEDING: - case PRECISION: - case PREPARE: - case PRESERVE: - case PRIOR: - case PRIVILEGES: - case PROCEDURAL: - case PROCEDURE: - case PUBLIC: - case QUOTE: - case RANGE: - case RANK: - case READ: - case READS: - case REAL: - case RECHECK: - case RECURSIVE: - case REF: - case REFERENCING: - case REFRESH: - case REGR_AVGX: - case REGR_AVGY: - case REGR_COUNT: - case REGR_INTERCEPT: - case REGR_SLOPE: - case REGR_SXX: - case REGR_SXY: - case REGR_SYY: - case REINDEX: - case RELATIVE: - case RELEASE: - case RENAME: - case REPEATABLE: - case REPLACE: - case RESET: - case RESTART: - case RESTRICT: - case RESULT: - case RETURN: - case RETURNED_CARDINALITY: - case RETURNED_LENGTH: - case RETURNED_OCTET_LENGTH: - case RETURNED_SQLSTATE: - case RETURNS: - case REVOKE: - case RIGHT: - case ROLE: - case ROLLBACK: - case ROLLUP: - case ROUTINE: - case ROUTINE_CATALOG: - case ROUTINE_NAME: - case ROUTINE_SCHEMA: - case ROW: - case ROW_COUNT: - case ROW_NUMBER: - case ROWS: - case RULE: - case SAVEPOINT: - case SCALE: - case SCHEMA: - case SCHEMA_NAME: - case SCOPE: - case SCOPE_CATALOG: - case SCOPE_NAME: - case SCOPE_SCHEMA: - case SCROLL: - case SEARCH: - case SECOND: - case SECTION: - case SECURITY: - case SELF: - case SENSITIVE: - case SEQUENCE: - case SEQUENCES: - case SERIALIZABLE: - case SERVER_NAME: - case SESSION: - case SET: - case SETOF: - case SETS: - case SHARE: - case SHOW: - case SIMPLE: - case SIZE: - case SMALLINT: - case SOME: - case SOURCE: - case SPACE: - case SPECIFIC: - case SPECIFIC_NAME: - case SPECIFICTYPE: - case SQL: - case SQLCODE: - case SQLERROR: - case SQLEXCEPTION: - case SQLSTATE: - case SQLWARNING: - case SQRT: - case STABLE: - case START: - case STATE: - case STATEMENT: - case STATIC: - case STATISTICS: - case STDDEV_POP: - case STDDEV_SAMP: - case STDIN: - case STDOUT: - case STORAGE: - case STRICT: - case STRUCTURE: - case STYLE: - case SUBCLASS_ORIGIN: - case SUBMULTISET: - case SUBSTRING: - case SUM: - case SYSID: - case SYSTEM: - case SYSTEM_USER: - case TABLE_NAME: - case TABLESPACE: - case TEMP: - case TEMPLATE: - case TEMPORARY: - case TIES: - case TIME: - case TIMESTAMP: - case TIMEZONE_HOUR: - case TIMEZONE_MINUTE: - case TOP: - case TOP_LEVEL_COUNT: - case TRANSACTION: - case TRANSACTION_ACTIVE: - case TRANSACTIONS_COMMITTED: - case TRANSACTIONS_ROLLED_BACK: - case TRANSFORM: - case TRANSFORMS: - case TRANSLATE: - case TRANSLATION: - case TREAT: - case TRIGGER: - case TRIGGER_CATALOG: - case TRIGGER_NAME: - case TRIGGER_SCHEMA: - case TRIM: - case TRUE: - case TRUNCATE: - case TRUSTED: - case TYPE: - case UESCAPE: - case UNBOUNDED: - case UNCOMMITTED: - case UNDER: - case UNENCRYPTED: - case UNKNOWN: - case UNLISTEN: - case UNNAMED: - case UNNEST: - case UNTIL: - case UPDATE: - case UPPER: - case USAGE: - case USER_DEFINED_TYPE_CATALOG: - case USER_DEFINED_TYPE_CODE: - case USER_DEFINED_TYPE_NAME: - case USER_DEFINED_TYPE_SCHEMA: - case VACUUM: - case VALID: - case VALIDATOR: - case VALUE: - case VALUES: - case VAR_POP: - case VAR_SAMP: - case VARCHAR: - case VARYING: - case VIEW: - case VOLATILE: - case WHENEVER: - case WIDTH_BUCKET: - case WITHIN: - case WITHOUT: - case WORK: - case WRITE: - case YEAR: - case ZONE: - case VERSION: - case ABSTIME: - case BIGSERIAL: - case BIT_VARYING: - case BOOL: - case BOX: - case BYTEA: - case CHARACTER_VARYING: - case CIDR: - case CIRCLE: - case FLOAT4: - case FLOAT8: - case INET: - case INT2: - case INT4: - case INT8: - case JSON: - case JSONB: - case LINE: - case LSEG: - case MACADDR: - case MACADDR8: - case MONEY: - case PG_LSN: - case POINT: - case POLYGON: - case RELTIME: - case SERIAL: - case SERIAL2: - case SERIAL4: - case SERIAL8: - case SMALLSERIAL: - case TEXT: - case TIMESTAMPTZ: - case TIMETZ: - case TSQUERY: - case TSVECTOR: - case TXID_SNAPSHOT: - case UUID: - case VARBIT: - case XML: - case DOUBLEQ_STRING_LITERAL: - case IDENTIFIER: - case IDENTIFIER_UNICODE: - { - setState(5551); - ((Exclude_elementContext)_localctx).column_name_ = identifier(0); - } - break; - case OPEN_PAREN: - { - setState(5552); - match(OPEN_PAREN); - setState(5553); - expr(0); - setState(5554); - match(CLOSE_PAREN); - } - break; - default: - throw new NoViableAltException(this); - } - setState(5559); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,682,_ctx) ) { - case 1: - { - setState(5558); - ((Exclude_elementContext)_localctx).opclass = identifier(0); - } - break; - } - setState(5562); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ASC || _la==DESC) { - { - setState(5561); - _la = _input.LA(1); - if ( !(_la==ASC || _la==DESC) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(5566); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NULLS) { - { - setState(5564); - match(NULLS); - setState(5565); - _la = _input.LA(1); - if ( !(_la==FIRST || _la==LAST) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Table_constraintContext extends ParserRuleContext { - public Name_Context constraint_name; - public Identifier_listContext columns; - public Identifier_listContext operators; - public IdentifierContext reftable; - public IdentifierContext action; - public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } - public TerminalNode DEFERABLE() { return getToken(PostgreSqlParser.DEFERABLE, 0); } - public TerminalNode INITIALLY() { return getToken(PostgreSqlParser.INITIALLY, 0); } - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } - public List OPEN_PAREN() { return getTokens(PostgreSqlParser.OPEN_PAREN); } - public TerminalNode OPEN_PAREN(int i) { - return getToken(PostgreSqlParser.OPEN_PAREN, i); - } - public ExprContext expr() { - return getRuleContext(ExprContext.class,0); - } - public List CLOSE_PAREN() { return getTokens(PostgreSqlParser.CLOSE_PAREN); } - public TerminalNode CLOSE_PAREN(int i) { - return getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - public TerminalNode UNIQUE() { return getToken(PostgreSqlParser.UNIQUE, 0); } - public TerminalNode PRIMARY() { return getToken(PostgreSqlParser.PRIMARY, 0); } - public TerminalNode KEY() { return getToken(PostgreSqlParser.KEY, 0); } - public Index_parametersContext index_parameters() { - return getRuleContext(Index_parametersContext.class,0); - } - public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } - public TerminalNode REFERENCES() { return getToken(PostgreSqlParser.REFERENCES, 0); } - public TerminalNode DEFERRED() { return getToken(PostgreSqlParser.DEFERRED, 0); } - public TerminalNode IMMEDIATE() { return getToken(PostgreSqlParser.IMMEDIATE, 0); } - public List identifier_list() { - return getRuleContexts(Identifier_listContext.class); - } - public Identifier_listContext identifier_list(int i) { - return getRuleContext(Identifier_listContext.class,i); - } - public TerminalNode EXCLUDE() { return getToken(PostgreSqlParser.EXCLUDE, 0); } - public Exclude_elementContext exclude_element() { - return getRuleContext(Exclude_elementContext.class,0); - } - public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); - } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } - public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } - public TerminalNode INHERIT() { return getToken(PostgreSqlParser.INHERIT, 0); } - public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } - public PredicateContext predicate() { - return getRuleContext(PredicateContext.class,0); - } - public TerminalNode MATCH() { return getToken(PostgreSqlParser.MATCH, 0); } - public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } - public TerminalNode PARTIAL() { return getToken(PostgreSqlParser.PARTIAL, 0); } - public TerminalNode MATCH_SIMPLE() { return getToken(PostgreSqlParser.MATCH_SIMPLE, 0); } - public List ON() { return getTokens(PostgreSqlParser.ON); } - public TerminalNode ON(int i) { - return getToken(PostgreSqlParser.ON, i); - } - public TerminalNode DELETE() { return getToken(PostgreSqlParser.DELETE, 0); } - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } - public Index_methodContext index_method() { - return getRuleContext(Index_methodContext.class,0); - } - public Table_constraintContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_table_constraint; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTable_constraint(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTable_constraint(this); - } - } - - public final Table_constraintContext table_constraint() throws RecognitionException { - Table_constraintContext _localctx = new Table_constraintContext(_ctx, getState()); - enterRule(_localctx, 516, RULE_table_constraint); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(5570); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==CONSTRAINT) { - { - setState(5568); - match(CONSTRAINT); - setState(5569); - ((Table_constraintContext)_localctx).constraint_name = name_(); - } - } - - setState(5637); - _errHandler.sync(this); - switch (_input.LA(1)) { - case CHECK: - { - { - setState(5572); - match(CHECK); - setState(5573); - match(OPEN_PAREN); - setState(5574); - expr(0); - setState(5575); - match(CLOSE_PAREN); - setState(5578); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NO) { - { - setState(5576); - match(NO); - setState(5577); - match(INHERIT); - } - } - - } - } - break; - case UNIQUE: - { - { - setState(5580); - match(UNIQUE); - setState(5581); - match(OPEN_PAREN); - setState(5582); - ((Table_constraintContext)_localctx).columns = identifier_list(); - setState(5583); - match(CLOSE_PAREN); - } - } - break; - case PRIMARY: - { - { - setState(5585); - match(PRIMARY); - setState(5586); - match(KEY); - setState(5587); - match(OPEN_PAREN); - setState(5588); - ((Table_constraintContext)_localctx).columns = identifier_list(); - setState(5589); - match(CLOSE_PAREN); - setState(5590); - index_parameters(); - } - } - break; - case EOF: - case DEFERABLE: - case EXCLUDE: - case INITIALLY: - case NOT: - case COMMA: - case CLOSE_PAREN: - case SEMI: - { - setState(5608); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==EXCLUDE) { - { - setState(5592); - match(EXCLUDE); - setState(5595); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==USING) { - { - setState(5593); - match(USING); - setState(5594); - index_method(); - } - } - - setState(5597); - match(OPEN_PAREN); - setState(5598); - exclude_element(); - setState(5599); - match(WITH); - setState(5600); - ((Table_constraintContext)_localctx).operators = identifier_list(); - setState(5601); - match(CLOSE_PAREN); - setState(5602); - index_parameters(); - { - setState(5603); - match(WHERE); - setState(5604); - match(OPEN_PAREN); - setState(5605); - predicate(0); - setState(5606); - match(CLOSE_PAREN); - } - } - } - - } - break; - case FOREIGN: - { - { - setState(5610); - match(FOREIGN); - setState(5611); - match(KEY); - setState(5612); - match(OPEN_PAREN); - setState(5613); - ((Table_constraintContext)_localctx).columns = identifier_list(); - setState(5614); - match(CLOSE_PAREN); - setState(5615); - match(REFERENCES); - setState(5616); - ((Table_constraintContext)_localctx).reftable = identifier(0); - setState(5618); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,689,_ctx) ) { - case 1: - { - setState(5617); - ((Table_constraintContext)_localctx).columns = identifier_list(); - } - break; - } - setState(5625); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,690,_ctx) ) { - case 1: - { - setState(5620); - match(MATCH); - setState(5621); - match(FULL); - } - break; - case 2: - { - setState(5622); - match(MATCH); - setState(5623); - match(PARTIAL); - } - break; - case 3: - { - setState(5624); - match(MATCH_SIMPLE); - } - break; - } - setState(5630); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,691,_ctx) ) { - case 1: - { - setState(5627); - match(ON); - setState(5628); - match(DELETE); - setState(5629); - ((Table_constraintContext)_localctx).action = identifier(0); - } - break; - } - setState(5635); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ON) { - { - setState(5632); - match(ON); - setState(5633); - match(UPDATE); - setState(5634); - ((Table_constraintContext)_localctx).action = identifier(0); - } - } - - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(5643); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,695,_ctx) ) { - case 1: - { - setState(5640); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NOT) { - { - setState(5639); - match(NOT); - } - } - - setState(5642); - match(DEFERABLE); - } - break; - } - setState(5647); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==INITIALLY) { - { - setState(5645); - match(INITIALLY); - setState(5646); - _la = _input.LA(1); - if ( !(_la==DEFERRED || _la==IMMEDIATE) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Role_nameContext extends ParserRuleContext { - public Name_Context name; - public Name_Context name_() { - return getRuleContext(Name_Context.class,0); - } - public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } - public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } - public TerminalNode PUBLIC() { return getToken(PostgreSqlParser.PUBLIC, 0); } - public Role_nameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_role_name; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRole_name(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRole_name(this); - } - } - - public final Role_nameContext role_name() throws RecognitionException { - Role_nameContext _localctx = new Role_nameContext(_ctx, getState()); - enterRule(_localctx, 518, RULE_role_name); - try { - setState(5653); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,697,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(5649); - ((Role_nameContext)_localctx).name = name_(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(5650); - match(CURRENT_USER); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(5651); - match(SESSION_USER); + setState(9770); + sconst(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(5652); - match(PUBLIC); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Role_name_listContext extends ParserRuleContext { - public List role_name() { - return getRuleContexts(Role_nameContext.class); - } - public Role_nameContext role_name(int i) { - return getRuleContext(Role_nameContext.class,i); - } - public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(PostgreSqlParser.COMMA, i); - } - public Role_name_listContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_role_name_list; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRole_name_list(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRole_name_list(this); - } - } - - public final Role_name_listContext role_name_list() throws RecognitionException { - Role_name_listContext _localctx = new Role_name_listContext(_ctx, getState()); - enterRule(_localctx, 520, RULE_role_name_list); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(5655); - role_name(); - setState(5660); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(5656); - match(COMMA); - setState(5657); - role_name(); - } - } - setState(5662); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Param_valueContext extends ParserRuleContext { - public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } - public TerminalNode OFF() { return getToken(PostgreSqlParser.OFF, 0); } - public TerminalNode TRUE() { return getToken(PostgreSqlParser.TRUE, 0); } - public TerminalNode FALSE() { return getToken(PostgreSqlParser.FALSE, 0); } - public TerminalNode YES() { return getToken(PostgreSqlParser.YES, 0); } - public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } - public TerminalNode NONE() { return getToken(PostgreSqlParser.NONE, 0); } - public TerminalNode SINGLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.SINGLEQ_STRING_LITERAL, 0); } - public ParameterOrNumericLiteralContext parameterOrNumericLiteral() { - return getRuleContext(ParameterOrNumericLiteralContext.class,0); - } - public ParameterOrIntegerLiteralContext parameterOrIntegerLiteral() { - return getRuleContext(ParameterOrIntegerLiteralContext.class,0); - } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Param_valueContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_param_value; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterParam_value(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitParam_value(this); - } - } - - public final Param_valueContext param_value() throws RecognitionException { - Param_valueContext _localctx = new Param_valueContext(_ctx, getState()); - enterRule(_localctx, 522, RULE_param_value); - try { - setState(5674); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,699,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(5663); - match(ON); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(5664); - match(OFF); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(5665); - match(TRUE); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(5666); - match(FALSE); + setState(9771); + bconst(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(5667); - match(YES); + setState(9772); + xconst(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(5668); - match(NO); + setState(9773); + func_name(); + setState(9781); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + { + setState(9774); + sconst(); + } + break; + case OPEN_PAREN: + { + setState(9775); + match(OPEN_PAREN); + setState(9776); + func_arg_list(); + setState(9777); + opt_sort_clause(); + setState(9778); + match(CLOSE_PAREN); + setState(9779); + sconst(); + } + break; + default: + throw new NoViableAltException(this); + } } break; case 7: enterOuterAlt(_localctx, 7); { - setState(5669); - match(NONE); + setState(9783); + consttypename(); + setState(9784); + sconst(); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(5670); - match(SINGLEQ_STRING_LITERAL); + setState(9786); + constinterval(); + setState(9795); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case EscapeStringConstant: + { + setState(9787); + sconst(); + setState(9788); + opt_interval(); + } + break; + case OPEN_PAREN: + { + setState(9790); + match(OPEN_PAREN); + setState(9791); + iconst(); + setState(9792); + match(CLOSE_PAREN); + setState(9793); + sconst(); + } + break; + default: + throw new NoViableAltException(this); + } } break; case 9: enterOuterAlt(_localctx, 9); { - setState(5671); - parameterOrNumericLiteral(); + setState(9797); + match(TRUE_P); } break; case 10: enterOuterAlt(_localctx, 10); { - setState(5672); - parameterOrIntegerLiteral(); + setState(9798); + match(FALSE_P); } break; case 11: enterOuterAlt(_localctx, 11); { - setState(5673); - identifier(0); + setState(9799); + match(NULL_P); } break; } @@ -47409,16 +85302,2670 @@ public class PostgreSqlParser extends Parser { return _localctx; } + @SuppressWarnings("CheckReturnValue") + public static class XconstContext extends ParserRuleContext { + public TerminalNode HexadecimalStringConstant() { return getToken(PostgreSqlParser.HexadecimalStringConstant, 0); } + public XconstContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xconst; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterXconst(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitXconst(this); + } + } + + public final XconstContext xconst() throws RecognitionException { + XconstContext _localctx = new XconstContext(_ctx, getState()); + enterRule(_localctx, 1350, RULE_xconst); + try { + enterOuterAlt(_localctx, 1); + { + setState(9802); + match(HexadecimalStringConstant); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BconstContext extends ParserRuleContext { + public TerminalNode BinaryStringConstant() { return getToken(PostgreSqlParser.BinaryStringConstant, 0); } + public BconstContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_bconst; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterBconst(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitBconst(this); + } + } + + public final BconstContext bconst() throws RecognitionException { + BconstContext _localctx = new BconstContext(_ctx, getState()); + enterRule(_localctx, 1352, RULE_bconst); + try { + enterOuterAlt(_localctx, 1); + { + setState(9804); + match(BinaryStringConstant); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FconstContext extends ParserRuleContext { + public TerminalNode Numeric() { return getToken(PostgreSqlParser.Numeric, 0); } + public FconstContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fconst; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFconst(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFconst(this); + } + } + + public final FconstContext fconst() throws RecognitionException { + FconstContext _localctx = new FconstContext(_ctx, getState()); + enterRule(_localctx, 1354, RULE_fconst); + try { + enterOuterAlt(_localctx, 1); + { + setState(9806); + match(Numeric); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IconstContext extends ParserRuleContext { + public TerminalNode Integral() { return getToken(PostgreSqlParser.Integral, 0); } + public IconstContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_iconst; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIconst(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIconst(this); + } + } + + public final IconstContext iconst() throws RecognitionException { + IconstContext _localctx = new IconstContext(_ctx, getState()); + enterRule(_localctx, 1356, RULE_iconst); + try { + enterOuterAlt(_localctx, 1); + { + setState(9808); + match(Integral); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SconstContext extends ParserRuleContext { + public AnysconstContext anysconst() { + return getRuleContext(AnysconstContext.class,0); + } + public Opt_uescapeContext opt_uescape() { + return getRuleContext(Opt_uescapeContext.class,0); + } + public SconstContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sconst; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSconst(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSconst(this); + } + } + + public final SconstContext sconst() throws RecognitionException { + SconstContext _localctx = new SconstContext(_ctx, getState()); + enterRule(_localctx, 1358, RULE_sconst); + try { + enterOuterAlt(_localctx, 1); + { + setState(9810); + anysconst(); + setState(9811); + opt_uescape(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AnysconstContext extends ParserRuleContext { + public TerminalNode StringConstant() { return getToken(PostgreSqlParser.StringConstant, 0); } + public TerminalNode UnicodeEscapeStringConstant() { return getToken(PostgreSqlParser.UnicodeEscapeStringConstant, 0); } + public TerminalNode BeginDollarStringConstant() { return getToken(PostgreSqlParser.BeginDollarStringConstant, 0); } + public TerminalNode EndDollarStringConstant() { return getToken(PostgreSqlParser.EndDollarStringConstant, 0); } + public List DollarText() { return getTokens(PostgreSqlParser.DollarText); } + public TerminalNode DollarText(int i) { + return getToken(PostgreSqlParser.DollarText, i); + } + public TerminalNode EscapeStringConstant() { return getToken(PostgreSqlParser.EscapeStringConstant, 0); } + public AnysconstContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_anysconst; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAnysconst(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAnysconst(this); + } + } + + public final AnysconstContext anysconst() throws RecognitionException { + AnysconstContext _localctx = new AnysconstContext(_ctx, getState()); + enterRule(_localctx, 1360, RULE_anysconst); + int _la; + try { + setState(9824); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringConstant: + enterOuterAlt(_localctx, 1); + { + setState(9813); + match(StringConstant); + } + break; + case UnicodeEscapeStringConstant: + enterOuterAlt(_localctx, 2); + { + setState(9814); + match(UnicodeEscapeStringConstant); + } + break; + case BeginDollarStringConstant: + enterOuterAlt(_localctx, 3); + { + setState(9815); + match(BeginDollarStringConstant); + setState(9819); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DollarText) { + { + { + setState(9816); + match(DollarText); + } + } + setState(9821); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(9822); + match(EndDollarStringConstant); + } + break; + case EscapeStringConstant: + enterOuterAlt(_localctx, 4); + { + setState(9823); + match(EscapeStringConstant); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_uescapeContext extends ParserRuleContext { + public TerminalNode UESCAPE() { return getToken(PostgreSqlParser.UESCAPE, 0); } + public AnysconstContext anysconst() { + return getRuleContext(AnysconstContext.class,0); + } + public Opt_uescapeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_uescape; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_uescape(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_uescape(this); + } + } + + public final Opt_uescapeContext opt_uescape() throws RecognitionException { + Opt_uescapeContext _localctx = new Opt_uescapeContext(_ctx, getState()); + enterRule(_localctx, 1362, RULE_opt_uescape); + try { + setState(9829); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,655,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9826); + match(UESCAPE); + setState(9827); + anysconst(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SignediconstContext extends ParserRuleContext { + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); + } + public TerminalNode PLUS() { return getToken(PostgreSqlParser.PLUS, 0); } + public TerminalNode MINUS() { return getToken(PostgreSqlParser.MINUS, 0); } + public SignediconstContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_signediconst; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSignediconst(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSignediconst(this); + } + } + + public final SignediconstContext signediconst() throws RecognitionException { + SignediconstContext _localctx = new SignediconstContext(_ctx, getState()); + enterRule(_localctx, 1364, RULE_signediconst); + try { + setState(9836); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Integral: + enterOuterAlt(_localctx, 1); + { + setState(9831); + iconst(); + } + break; + case PLUS: + enterOuterAlt(_localctx, 2); + { + setState(9832); + match(PLUS); + setState(9833); + iconst(); + } + break; + case MINUS: + enterOuterAlt(_localctx, 3); + { + setState(9834); + match(MINUS); + setState(9835); + iconst(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RoleidContext extends ParserRuleContext { + public RolespecContext rolespec() { + return getRuleContext(RolespecContext.class,0); + } + public RoleidContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_roleid; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRoleid(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRoleid(this); + } + } + + public final RoleidContext roleid() throws RecognitionException { + RoleidContext _localctx = new RoleidContext(_ctx, getState()); + enterRule(_localctx, 1366, RULE_roleid); + try { + enterOuterAlt(_localctx, 1); + { + setState(9838); + rolespec(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RolespecContext extends ParserRuleContext { + public NonreservedwordContext nonreservedword() { + return getRuleContext(NonreservedwordContext.class,0); + } + public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } + public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } + public RolespecContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_rolespec; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRolespec(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRolespec(this); + } + } + + public final RolespecContext rolespec() throws RecognitionException { + RolespecContext _localctx = new RolespecContext(_ctx, getState()); + enterRule(_localctx, 1368, RULE_rolespec); + try { + setState(9843); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(9840); + nonreservedword(); + } + break; + case CURRENT_USER: + enterOuterAlt(_localctx, 2); + { + setState(9841); + match(CURRENT_USER); + } + break; + case SESSION_USER: + enterOuterAlt(_localctx, 3); + { + setState(9842); + match(SESSION_USER); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Role_listContext extends ParserRuleContext { + public List rolespec() { + return getRuleContexts(RolespecContext.class); + } + public RolespecContext rolespec(int i) { + return getRuleContext(RolespecContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Role_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_role_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRole_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRole_list(this); + } + } + + public final Role_listContext role_list() throws RecognitionException { + Role_listContext _localctx = new Role_listContext(_ctx, getState()); + enterRule(_localctx, 1370, RULE_role_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9845); + rolespec(); + setState(9850); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(9846); + match(COMMA); + setState(9847); + rolespec(); + } + } + setState(9852); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ColidContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Unreserved_keywordContext unreserved_keyword() { + return getRuleContext(Unreserved_keywordContext.class,0); + } + public Col_name_keywordContext col_name_keyword() { + return getRuleContext(Col_name_keywordContext.class,0); + } + public Plsql_unreserved_keywordContext plsql_unreserved_keyword() { + return getRuleContext(Plsql_unreserved_keywordContext.class,0); + } + public TerminalNode LEFT() { return getToken(PostgreSqlParser.LEFT, 0); } + public TerminalNode RIGHT() { return getToken(PostgreSqlParser.RIGHT, 0); } + public ColidContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_colid; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColid(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColid(this); + } + } + + public final ColidContext colid() throws RecognitionException { + ColidContext _localctx = new ColidContext(_ctx, getState()); + enterRule(_localctx, 1372, RULE_colid); + try { + setState(9859); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,659,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9853); + identifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9854); + unreserved_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9855); + col_name_keyword(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9856); + plsql_unreserved_keyword(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(9857); + match(LEFT); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(9858); + match(RIGHT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Table_aliasContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Unreserved_keywordContext unreserved_keyword() { + return getRuleContext(Unreserved_keywordContext.class,0); + } + public Col_name_keywordContext col_name_keyword() { + return getRuleContext(Col_name_keywordContext.class,0); + } + public Plsql_unreserved_keywordContext plsql_unreserved_keyword() { + return getRuleContext(Plsql_unreserved_keywordContext.class,0); + } + public Table_aliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_table_alias; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTable_alias(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTable_alias(this); + } + } + + public final Table_aliasContext table_alias() throws RecognitionException { + Table_aliasContext _localctx = new Table_aliasContext(_ctx, getState()); + enterRule(_localctx, 1374, RULE_table_alias); + try { + setState(9865); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,660,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9861); + identifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9862); + unreserved_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9863); + col_name_keyword(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9864); + plsql_unreserved_keyword(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_function_nameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Unreserved_keywordContext unreserved_keyword() { + return getRuleContext(Unreserved_keywordContext.class,0); + } + public Plsql_unreserved_keywordContext plsql_unreserved_keyword() { + return getRuleContext(Plsql_unreserved_keywordContext.class,0); + } + public Type_func_name_keywordContext type_func_name_keyword() { + return getRuleContext(Type_func_name_keywordContext.class,0); + } + public Type_function_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_function_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterType_function_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitType_function_name(this); + } + } + + public final Type_function_nameContext type_function_name() throws RecognitionException { + Type_function_nameContext _localctx = new Type_function_nameContext(_ctx, getState()); + enterRule(_localctx, 1376, RULE_type_function_name); + try { + setState(9871); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,661,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9867); + identifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9868); + unreserved_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9869); + plsql_unreserved_keyword(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9870); + type_func_name_keyword(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NonreservedwordContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Unreserved_keywordContext unreserved_keyword() { + return getRuleContext(Unreserved_keywordContext.class,0); + } + public Col_name_keywordContext col_name_keyword() { + return getRuleContext(Col_name_keywordContext.class,0); + } + public Type_func_name_keywordContext type_func_name_keyword() { + return getRuleContext(Type_func_name_keywordContext.class,0); + } + public NonreservedwordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nonreservedword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNonreservedword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNonreservedword(this); + } + } + + public final NonreservedwordContext nonreservedword() throws RecognitionException { + NonreservedwordContext _localctx = new NonreservedwordContext(_ctx, getState()); + enterRule(_localctx, 1378, RULE_nonreservedword); + try { + setState(9877); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,662,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9873); + identifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9874); + unreserved_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9875); + col_name_keyword(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9876); + type_func_name_keyword(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CollabelContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Plsql_unreserved_keywordContext plsql_unreserved_keyword() { + return getRuleContext(Plsql_unreserved_keywordContext.class,0); + } + public Unreserved_keywordContext unreserved_keyword() { + return getRuleContext(Unreserved_keywordContext.class,0); + } + public Col_name_keywordContext col_name_keyword() { + return getRuleContext(Col_name_keywordContext.class,0); + } + public Type_func_name_keywordContext type_func_name_keyword() { + return getRuleContext(Type_func_name_keywordContext.class,0); + } + public Reserved_keywordContext reserved_keyword() { + return getRuleContext(Reserved_keywordContext.class,0); + } + public CollabelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_collabel; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCollabel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCollabel(this); + } + } + + public final CollabelContext collabel() throws RecognitionException { + CollabelContext _localctx = new CollabelContext(_ctx, getState()); + enterRule(_localctx, 1380, RULE_collabel); + try { + setState(9885); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,663,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9879); + identifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9880); + plsql_unreserved_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9881); + unreserved_keyword(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9882); + col_name_keyword(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(9883); + type_func_name_keyword(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(9884); + reserved_keyword(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(PostgreSqlParser.Identifier, 0); } + public Opt_uescapeContext opt_uescape() { + return getRuleContext(Opt_uescapeContext.class,0); + } + public TerminalNode QuotedIdentifier() { return getToken(PostgreSqlParser.QuotedIdentifier, 0); } + public TerminalNode UnicodeQuotedIdentifier() { return getToken(PostgreSqlParser.UnicodeQuotedIdentifier, 0); } + public PlsqlidentifierContext plsqlidentifier() { + return getRuleContext(PlsqlidentifierContext.class,0); + } + public Plsql_unreserved_keywordContext plsql_unreserved_keyword() { + return getRuleContext(Plsql_unreserved_keywordContext.class,0); + } + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIdentifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIdentifier(this); + } + } + + public final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 1382, RULE_identifier); + try { + setState(9893); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(9887); + match(Identifier); + setState(9888); + opt_uescape(); + } + break; + case QuotedIdentifier: + enterOuterAlt(_localctx, 2); + { + setState(9889); + match(QuotedIdentifier); + } + break; + case UnicodeQuotedIdentifier: + enterOuterAlt(_localctx, 3); + { + setState(9890); + match(UnicodeQuotedIdentifier); + } + break; + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 4); + { + setState(9891); + plsqlidentifier(); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case OUTER_P: + case ABSOLUTE_P: + case BACKWARD: + case CHAIN: + case CLOSE: + case COMMIT: + case CONTINUE_P: + case CURSOR: + case FIRST_P: + case FORWARD: + case INSERT: + case LAST_P: + case MOVE: + case NEXT: + case NO: + case OPTION: + case PRIOR: + case RELATIVE_P: + case RESET: + case ROLLBACK: + case SCHEMA: + case SCROLL: + case SET: + case TYPE_P: + case CALL: + case CURRENT_P: + case ROWTYPE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + enterOuterAlt(_localctx, 5); + { + setState(9892); + plsql_unreserved_keyword(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PlsqlidentifierContext extends ParserRuleContext { + public TerminalNode PLSQLIDENTIFIER() { return getToken(PostgreSqlParser.PLSQLIDENTIFIER, 0); } + public PlsqlidentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_plsqlidentifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPlsqlidentifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPlsqlidentifier(this); + } + } + + public final PlsqlidentifierContext plsqlidentifier() throws RecognitionException { + PlsqlidentifierContext _localctx = new PlsqlidentifierContext(_ctx, getState()); + enterRule(_localctx, 1384, RULE_plsqlidentifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(9895); + match(PLSQLIDENTIFIER); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Unreserved_keywordContext extends ParserRuleContext { + public TerminalNode ABORT_P() { return getToken(PostgreSqlParser.ABORT_P, 0); } + public TerminalNode ABSOLUTE_P() { return getToken(PostgreSqlParser.ABSOLUTE_P, 0); } + public TerminalNode ACCESS() { return getToken(PostgreSqlParser.ACCESS, 0); } + public TerminalNode ACTION() { return getToken(PostgreSqlParser.ACTION, 0); } + public TerminalNode ADD_P() { return getToken(PostgreSqlParser.ADD_P, 0); } + public TerminalNode ADMIN() { return getToken(PostgreSqlParser.ADMIN, 0); } + public TerminalNode AFTER() { return getToken(PostgreSqlParser.AFTER, 0); } + public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } + public TerminalNode ALSO() { return getToken(PostgreSqlParser.ALSO, 0); } + public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } + public TerminalNode ALWAYS() { return getToken(PostgreSqlParser.ALWAYS, 0); } + public TerminalNode ASSERTION() { return getToken(PostgreSqlParser.ASSERTION, 0); } + public TerminalNode ASSIGNMENT() { return getToken(PostgreSqlParser.ASSIGNMENT, 0); } + public TerminalNode AT() { return getToken(PostgreSqlParser.AT, 0); } + public TerminalNode ATTACH() { return getToken(PostgreSqlParser.ATTACH, 0); } + public TerminalNode ATTRIBUTE() { return getToken(PostgreSqlParser.ATTRIBUTE, 0); } + public TerminalNode BACKWARD() { return getToken(PostgreSqlParser.BACKWARD, 0); } + public TerminalNode BEFORE() { return getToken(PostgreSqlParser.BEFORE, 0); } + public TerminalNode BEGIN_P() { return getToken(PostgreSqlParser.BEGIN_P, 0); } + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public TerminalNode CACHE() { return getToken(PostgreSqlParser.CACHE, 0); } + public TerminalNode CALL() { return getToken(PostgreSqlParser.CALL, 0); } + public TerminalNode CALLED() { return getToken(PostgreSqlParser.CALLED, 0); } + public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } + public TerminalNode CASCADED() { return getToken(PostgreSqlParser.CASCADED, 0); } + public TerminalNode CATALOG() { return getToken(PostgreSqlParser.CATALOG, 0); } + public TerminalNode CHAIN() { return getToken(PostgreSqlParser.CHAIN, 0); } + public TerminalNode CHARACTERISTICS() { return getToken(PostgreSqlParser.CHARACTERISTICS, 0); } + public TerminalNode CHECKPOINT() { return getToken(PostgreSqlParser.CHECKPOINT, 0); } + public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } + public TerminalNode CLOSE() { return getToken(PostgreSqlParser.CLOSE, 0); } + public TerminalNode CLUSTER() { return getToken(PostgreSqlParser.CLUSTER, 0); } + public TerminalNode COLUMNS() { return getToken(PostgreSqlParser.COLUMNS, 0); } + public TerminalNode COMMENT() { return getToken(PostgreSqlParser.COMMENT, 0); } + public TerminalNode COMMENTS() { return getToken(PostgreSqlParser.COMMENTS, 0); } + public TerminalNode COMMIT() { return getToken(PostgreSqlParser.COMMIT, 0); } + public TerminalNode COMMITTED() { return getToken(PostgreSqlParser.COMMITTED, 0); } + public TerminalNode CONFIGURATION() { return getToken(PostgreSqlParser.CONFIGURATION, 0); } + public TerminalNode CONFLICT() { return getToken(PostgreSqlParser.CONFLICT, 0); } + public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } + public TerminalNode CONSTRAINTS() { return getToken(PostgreSqlParser.CONSTRAINTS, 0); } + public TerminalNode CONTENT_P() { return getToken(PostgreSqlParser.CONTENT_P, 0); } + public TerminalNode CONTINUE_P() { return getToken(PostgreSqlParser.CONTINUE_P, 0); } + public TerminalNode CONVERSION_P() { return getToken(PostgreSqlParser.CONVERSION_P, 0); } + public TerminalNode COPY() { return getToken(PostgreSqlParser.COPY, 0); } + public TerminalNode COST() { return getToken(PostgreSqlParser.COST, 0); } + public TerminalNode CSV() { return getToken(PostgreSqlParser.CSV, 0); } + public TerminalNode CUBE() { return getToken(PostgreSqlParser.CUBE, 0); } + public TerminalNode CURRENT_P() { return getToken(PostgreSqlParser.CURRENT_P, 0); } + public TerminalNode CURSOR() { return getToken(PostgreSqlParser.CURSOR, 0); } + public TerminalNode CYCLE() { return getToken(PostgreSqlParser.CYCLE, 0); } + public TerminalNode DATA_P() { return getToken(PostgreSqlParser.DATA_P, 0); } + public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } + public TerminalNode DAY_P() { return getToken(PostgreSqlParser.DAY_P, 0); } + public TerminalNode DEALLOCATE() { return getToken(PostgreSqlParser.DEALLOCATE, 0); } + public TerminalNode DECLARE() { return getToken(PostgreSqlParser.DECLARE, 0); } + public TerminalNode DEFAULTS() { return getToken(PostgreSqlParser.DEFAULTS, 0); } + public TerminalNode DEFERRED() { return getToken(PostgreSqlParser.DEFERRED, 0); } + public TerminalNode DEFINER() { return getToken(PostgreSqlParser.DEFINER, 0); } + public TerminalNode DELETE_P() { return getToken(PostgreSqlParser.DELETE_P, 0); } + public TerminalNode DELIMITER() { return getToken(PostgreSqlParser.DELIMITER, 0); } + public TerminalNode DELIMITERS() { return getToken(PostgreSqlParser.DELIMITERS, 0); } + public TerminalNode DEPENDS() { return getToken(PostgreSqlParser.DEPENDS, 0); } + public TerminalNode DETACH() { return getToken(PostgreSqlParser.DETACH, 0); } + public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } + public TerminalNode DISABLE_P() { return getToken(PostgreSqlParser.DISABLE_P, 0); } + public TerminalNode DISCARD() { return getToken(PostgreSqlParser.DISCARD, 0); } + public TerminalNode DOCUMENT_P() { return getToken(PostgreSqlParser.DOCUMENT_P, 0); } + public TerminalNode DOMAIN_P() { return getToken(PostgreSqlParser.DOMAIN_P, 0); } + public TerminalNode DOUBLE_P() { return getToken(PostgreSqlParser.DOUBLE_P, 0); } + public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode EACH() { return getToken(PostgreSqlParser.EACH, 0); } + public TerminalNode ENABLE_P() { return getToken(PostgreSqlParser.ENABLE_P, 0); } + public TerminalNode ENCODING() { return getToken(PostgreSqlParser.ENCODING, 0); } + public TerminalNode ENCRYPTED() { return getToken(PostgreSqlParser.ENCRYPTED, 0); } + public TerminalNode ENUM_P() { return getToken(PostgreSqlParser.ENUM_P, 0); } + public TerminalNode ESCAPE() { return getToken(PostgreSqlParser.ESCAPE, 0); } + public TerminalNode EVENT() { return getToken(PostgreSqlParser.EVENT, 0); } + public TerminalNode EXCLUDE() { return getToken(PostgreSqlParser.EXCLUDE, 0); } + public TerminalNode EXCLUDING() { return getToken(PostgreSqlParser.EXCLUDING, 0); } + public TerminalNode EXCLUSIVE() { return getToken(PostgreSqlParser.EXCLUSIVE, 0); } + public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } + public TerminalNode EXPLAIN() { return getToken(PostgreSqlParser.EXPLAIN, 0); } + public TerminalNode EXPRESSION() { return getToken(PostgreSqlParser.EXPRESSION, 0); } + public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } + public TerminalNode EXTERNAL() { return getToken(PostgreSqlParser.EXTERNAL, 0); } + public TerminalNode FAMILY() { return getToken(PostgreSqlParser.FAMILY, 0); } + public TerminalNode FILTER() { return getToken(PostgreSqlParser.FILTER, 0); } + public TerminalNode FIRST_P() { return getToken(PostgreSqlParser.FIRST_P, 0); } + public TerminalNode FOLLOWING() { return getToken(PostgreSqlParser.FOLLOWING, 0); } + public TerminalNode FORCE() { return getToken(PostgreSqlParser.FORCE, 0); } + public TerminalNode FORWARD() { return getToken(PostgreSqlParser.FORWARD, 0); } + public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } + public TerminalNode FUNCTIONS() { return getToken(PostgreSqlParser.FUNCTIONS, 0); } + public TerminalNode GENERATED() { return getToken(PostgreSqlParser.GENERATED, 0); } + public TerminalNode GLOBAL() { return getToken(PostgreSqlParser.GLOBAL, 0); } + public TerminalNode GRANTED() { return getToken(PostgreSqlParser.GRANTED, 0); } + public TerminalNode GROUPS() { return getToken(PostgreSqlParser.GROUPS, 0); } + public TerminalNode HANDLER() { return getToken(PostgreSqlParser.HANDLER, 0); } + public TerminalNode HEADER_P() { return getToken(PostgreSqlParser.HEADER_P, 0); } + public TerminalNode HOLD() { return getToken(PostgreSqlParser.HOLD, 0); } + public TerminalNode HOUR_P() { return getToken(PostgreSqlParser.HOUR_P, 0); } + public TerminalNode IDENTITY_P() { return getToken(PostgreSqlParser.IDENTITY_P, 0); } + public TerminalNode IF_P() { return getToken(PostgreSqlParser.IF_P, 0); } + public TerminalNode IMMEDIATE() { return getToken(PostgreSqlParser.IMMEDIATE, 0); } + public TerminalNode IMMUTABLE() { return getToken(PostgreSqlParser.IMMUTABLE, 0); } + public TerminalNode IMPLICIT_P() { return getToken(PostgreSqlParser.IMPLICIT_P, 0); } + public TerminalNode IMPORT_P() { return getToken(PostgreSqlParser.IMPORT_P, 0); } + public TerminalNode INCLUDE() { return getToken(PostgreSqlParser.INCLUDE, 0); } + public TerminalNode INCLUDING() { return getToken(PostgreSqlParser.INCLUDING, 0); } + public TerminalNode INCREMENT() { return getToken(PostgreSqlParser.INCREMENT, 0); } + public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } + public TerminalNode INDEXES() { return getToken(PostgreSqlParser.INDEXES, 0); } + public TerminalNode INHERIT() { return getToken(PostgreSqlParser.INHERIT, 0); } + public TerminalNode INHERITS() { return getToken(PostgreSqlParser.INHERITS, 0); } + public TerminalNode INLINE_P() { return getToken(PostgreSqlParser.INLINE_P, 0); } + public TerminalNode INPUT_P() { return getToken(PostgreSqlParser.INPUT_P, 0); } + public TerminalNode INSENSITIVE() { return getToken(PostgreSqlParser.INSENSITIVE, 0); } + public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } + public TerminalNode INSTEAD() { return getToken(PostgreSqlParser.INSTEAD, 0); } + public TerminalNode INVOKER() { return getToken(PostgreSqlParser.INVOKER, 0); } + public TerminalNode ISOLATION() { return getToken(PostgreSqlParser.ISOLATION, 0); } + public TerminalNode KEY() { return getToken(PostgreSqlParser.KEY, 0); } + public TerminalNode LABEL() { return getToken(PostgreSqlParser.LABEL, 0); } + public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } + public TerminalNode LARGE_P() { return getToken(PostgreSqlParser.LARGE_P, 0); } + public TerminalNode LAST_P() { return getToken(PostgreSqlParser.LAST_P, 0); } + public TerminalNode LEAKPROOF() { return getToken(PostgreSqlParser.LEAKPROOF, 0); } + public TerminalNode LEVEL() { return getToken(PostgreSqlParser.LEVEL, 0); } + public TerminalNode LISTEN() { return getToken(PostgreSqlParser.LISTEN, 0); } + public TerminalNode LOAD() { return getToken(PostgreSqlParser.LOAD, 0); } + public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } + public TerminalNode LOCATION() { return getToken(PostgreSqlParser.LOCATION, 0); } + public TerminalNode LOCK_P() { return getToken(PostgreSqlParser.LOCK_P, 0); } + public TerminalNode LOCKED() { return getToken(PostgreSqlParser.LOCKED, 0); } + public TerminalNode LOGGED() { return getToken(PostgreSqlParser.LOGGED, 0); } + public TerminalNode MAPPING() { return getToken(PostgreSqlParser.MAPPING, 0); } + public TerminalNode MATCH() { return getToken(PostgreSqlParser.MATCH, 0); } + public TerminalNode MATERIALIZED() { return getToken(PostgreSqlParser.MATERIALIZED, 0); } + public TerminalNode MAXVALUE() { return getToken(PostgreSqlParser.MAXVALUE, 0); } + public TerminalNode METHOD() { return getToken(PostgreSqlParser.METHOD, 0); } + public TerminalNode MINUTE_P() { return getToken(PostgreSqlParser.MINUTE_P, 0); } + public TerminalNode MINVALUE() { return getToken(PostgreSqlParser.MINVALUE, 0); } + public TerminalNode MODE() { return getToken(PostgreSqlParser.MODE, 0); } + public TerminalNode MONTH_P() { return getToken(PostgreSqlParser.MONTH_P, 0); } + public TerminalNode MOVE() { return getToken(PostgreSqlParser.MOVE, 0); } + public TerminalNode NAME_P() { return getToken(PostgreSqlParser.NAME_P, 0); } + public TerminalNode NAMES() { return getToken(PostgreSqlParser.NAMES, 0); } + public TerminalNode NEW() { return getToken(PostgreSqlParser.NEW, 0); } + public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } + public TerminalNode NFC() { return getToken(PostgreSqlParser.NFC, 0); } + public TerminalNode NFD() { return getToken(PostgreSqlParser.NFD, 0); } + public TerminalNode NFKC() { return getToken(PostgreSqlParser.NFKC, 0); } + public TerminalNode NFKD() { return getToken(PostgreSqlParser.NFKD, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode NORMALIZED() { return getToken(PostgreSqlParser.NORMALIZED, 0); } + public TerminalNode NOTHING() { return getToken(PostgreSqlParser.NOTHING, 0); } + public TerminalNode NOTIFY() { return getToken(PostgreSqlParser.NOTIFY, 0); } + public TerminalNode NOWAIT() { return getToken(PostgreSqlParser.NOWAIT, 0); } + public TerminalNode NULLS_P() { return getToken(PostgreSqlParser.NULLS_P, 0); } + public TerminalNode OBJECT_P() { return getToken(PostgreSqlParser.OBJECT_P, 0); } + public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } + public TerminalNode OFF() { return getToken(PostgreSqlParser.OFF, 0); } + public TerminalNode OIDS() { return getToken(PostgreSqlParser.OIDS, 0); } + public TerminalNode OLD() { return getToken(PostgreSqlParser.OLD, 0); } + public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } + public TerminalNode ORDINALITY() { return getToken(PostgreSqlParser.ORDINALITY, 0); } + public TerminalNode OTHERS() { return getToken(PostgreSqlParser.OTHERS, 0); } + public TerminalNode OVER() { return getToken(PostgreSqlParser.OVER, 0); } + public TerminalNode OVERRIDING() { return getToken(PostgreSqlParser.OVERRIDING, 0); } + public TerminalNode OWNED() { return getToken(PostgreSqlParser.OWNED, 0); } + public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } + public TerminalNode PARALLEL() { return getToken(PostgreSqlParser.PARALLEL, 0); } + public TerminalNode PARSER() { return getToken(PostgreSqlParser.PARSER, 0); } + public TerminalNode PARTIAL() { return getToken(PostgreSqlParser.PARTIAL, 0); } + public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } + public TerminalNode PASSING() { return getToken(PostgreSqlParser.PASSING, 0); } + public TerminalNode PASSWORD() { return getToken(PostgreSqlParser.PASSWORD, 0); } + public TerminalNode PLANS() { return getToken(PostgreSqlParser.PLANS, 0); } + public TerminalNode POLICY() { return getToken(PostgreSqlParser.POLICY, 0); } + public TerminalNode PRECEDING() { return getToken(PostgreSqlParser.PRECEDING, 0); } + public TerminalNode PREPARE() { return getToken(PostgreSqlParser.PREPARE, 0); } + public TerminalNode PREPARED() { return getToken(PostgreSqlParser.PREPARED, 0); } + public TerminalNode PRESERVE() { return getToken(PostgreSqlParser.PRESERVE, 0); } + public TerminalNode PRIOR() { return getToken(PostgreSqlParser.PRIOR, 0); } + public TerminalNode PRIVILEGES() { return getToken(PostgreSqlParser.PRIVILEGES, 0); } + public TerminalNode PROCEDURAL() { return getToken(PostgreSqlParser.PROCEDURAL, 0); } + public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } + public TerminalNode PROCEDURES() { return getToken(PostgreSqlParser.PROCEDURES, 0); } + public TerminalNode PROGRAM() { return getToken(PostgreSqlParser.PROGRAM, 0); } + public TerminalNode PUBLICATION() { return getToken(PostgreSqlParser.PUBLICATION, 0); } + public TerminalNode QUOTE() { return getToken(PostgreSqlParser.QUOTE, 0); } + public TerminalNode RANGE() { return getToken(PostgreSqlParser.RANGE, 0); } + public TerminalNode READ() { return getToken(PostgreSqlParser.READ, 0); } + public TerminalNode REASSIGN() { return getToken(PostgreSqlParser.REASSIGN, 0); } + public TerminalNode RECHECK() { return getToken(PostgreSqlParser.RECHECK, 0); } + public TerminalNode RECURSIVE() { return getToken(PostgreSqlParser.RECURSIVE, 0); } + public TerminalNode REF() { return getToken(PostgreSqlParser.REF, 0); } + public TerminalNode REFERENCING() { return getToken(PostgreSqlParser.REFERENCING, 0); } + public TerminalNode REFRESH() { return getToken(PostgreSqlParser.REFRESH, 0); } + public TerminalNode REINDEX() { return getToken(PostgreSqlParser.REINDEX, 0); } + public TerminalNode RELATIVE_P() { return getToken(PostgreSqlParser.RELATIVE_P, 0); } + public TerminalNode RELEASE() { return getToken(PostgreSqlParser.RELEASE, 0); } + public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } + public TerminalNode REPEATABLE() { return getToken(PostgreSqlParser.REPEATABLE, 0); } + public TerminalNode REPLICA() { return getToken(PostgreSqlParser.REPLICA, 0); } + public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } + public TerminalNode RESTART() { return getToken(PostgreSqlParser.RESTART, 0); } + public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } + public TerminalNode RETURNS() { return getToken(PostgreSqlParser.RETURNS, 0); } + public TerminalNode REVOKE() { return getToken(PostgreSqlParser.REVOKE, 0); } + public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } + public TerminalNode ROLLBACK() { return getToken(PostgreSqlParser.ROLLBACK, 0); } + public TerminalNode ROLLUP() { return getToken(PostgreSqlParser.ROLLUP, 0); } + public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } + public TerminalNode ROUTINES() { return getToken(PostgreSqlParser.ROUTINES, 0); } + public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } + public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } + public TerminalNode SAVEPOINT() { return getToken(PostgreSqlParser.SAVEPOINT, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode SCHEMAS() { return getToken(PostgreSqlParser.SCHEMAS, 0); } + public TerminalNode SCROLL() { return getToken(PostgreSqlParser.SCROLL, 0); } + public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } + public TerminalNode SECOND_P() { return getToken(PostgreSqlParser.SECOND_P, 0); } + public TerminalNode SECURITY() { return getToken(PostgreSqlParser.SECURITY, 0); } + public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } + public TerminalNode SEQUENCES() { return getToken(PostgreSqlParser.SEQUENCES, 0); } + public TerminalNode SERIALIZABLE() { return getToken(PostgreSqlParser.SERIALIZABLE, 0); } + public TerminalNode SERVER() { return getToken(PostgreSqlParser.SERVER, 0); } + public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode SETS() { return getToken(PostgreSqlParser.SETS, 0); } + public TerminalNode SHARE() { return getToken(PostgreSqlParser.SHARE, 0); } + public TerminalNode SHOW() { return getToken(PostgreSqlParser.SHOW, 0); } + public TerminalNode SIMPLE() { return getToken(PostgreSqlParser.SIMPLE, 0); } + public TerminalNode SKIP_P() { return getToken(PostgreSqlParser.SKIP_P, 0); } + public TerminalNode SNAPSHOT() { return getToken(PostgreSqlParser.SNAPSHOT, 0); } + public TerminalNode SQL_P() { return getToken(PostgreSqlParser.SQL_P, 0); } + public TerminalNode STABLE() { return getToken(PostgreSqlParser.STABLE, 0); } + public TerminalNode STANDALONE_P() { return getToken(PostgreSqlParser.STANDALONE_P, 0); } + public TerminalNode START() { return getToken(PostgreSqlParser.START, 0); } + public TerminalNode STATEMENT() { return getToken(PostgreSqlParser.STATEMENT, 0); } + public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } + public TerminalNode STDIN() { return getToken(PostgreSqlParser.STDIN, 0); } + public TerminalNode STDOUT() { return getToken(PostgreSqlParser.STDOUT, 0); } + public TerminalNode STORAGE() { return getToken(PostgreSqlParser.STORAGE, 0); } + public TerminalNode STORED() { return getToken(PostgreSqlParser.STORED, 0); } + public TerminalNode STRICT_P() { return getToken(PostgreSqlParser.STRICT_P, 0); } + public TerminalNode STRIP_P() { return getToken(PostgreSqlParser.STRIP_P, 0); } + public TerminalNode SUBSCRIPTION() { return getToken(PostgreSqlParser.SUBSCRIPTION, 0); } + public TerminalNode SUPPORT() { return getToken(PostgreSqlParser.SUPPORT, 0); } + public TerminalNode SYSID() { return getToken(PostgreSqlParser.SYSID, 0); } + public TerminalNode SYSTEM_P() { return getToken(PostgreSqlParser.SYSTEM_P, 0); } + public TerminalNode TABLES() { return getToken(PostgreSqlParser.TABLES, 0); } + public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } + public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } + public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } + public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } + public TerminalNode TEXT_P() { return getToken(PostgreSqlParser.TEXT_P, 0); } + public TerminalNode TIES() { return getToken(PostgreSqlParser.TIES, 0); } + public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } + public TerminalNode TRANSFORM() { return getToken(PostgreSqlParser.TRANSFORM, 0); } + public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } + public TerminalNode TRUNCATE() { return getToken(PostgreSqlParser.TRUNCATE, 0); } + public TerminalNode TRUSTED() { return getToken(PostgreSqlParser.TRUSTED, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TerminalNode TYPES_P() { return getToken(PostgreSqlParser.TYPES_P, 0); } + public TerminalNode UESCAPE() { return getToken(PostgreSqlParser.UESCAPE, 0); } + public TerminalNode UNBOUNDED() { return getToken(PostgreSqlParser.UNBOUNDED, 0); } + public TerminalNode UNCOMMITTED() { return getToken(PostgreSqlParser.UNCOMMITTED, 0); } + public TerminalNode UNENCRYPTED() { return getToken(PostgreSqlParser.UNENCRYPTED, 0); } + public TerminalNode UNKNOWN() { return getToken(PostgreSqlParser.UNKNOWN, 0); } + public TerminalNode UNLISTEN() { return getToken(PostgreSqlParser.UNLISTEN, 0); } + public TerminalNode UNLOGGED() { return getToken(PostgreSqlParser.UNLOGGED, 0); } + public TerminalNode UNTIL() { return getToken(PostgreSqlParser.UNTIL, 0); } + public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } + public TerminalNode VACUUM() { return getToken(PostgreSqlParser.VACUUM, 0); } + public TerminalNode VALID() { return getToken(PostgreSqlParser.VALID, 0); } + public TerminalNode VALIDATE() { return getToken(PostgreSqlParser.VALIDATE, 0); } + public TerminalNode VALIDATOR() { return getToken(PostgreSqlParser.VALIDATOR, 0); } + public TerminalNode VALUE_P() { return getToken(PostgreSqlParser.VALUE_P, 0); } + public TerminalNode VARYING() { return getToken(PostgreSqlParser.VARYING, 0); } + public TerminalNode VERSION_P() { return getToken(PostgreSqlParser.VERSION_P, 0); } + public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } + public TerminalNode VIEWS() { return getToken(PostgreSqlParser.VIEWS, 0); } + public TerminalNode VOLATILE() { return getToken(PostgreSqlParser.VOLATILE, 0); } + public TerminalNode WHITESPACE_P() { return getToken(PostgreSqlParser.WHITESPACE_P, 0); } + public TerminalNode WITHIN() { return getToken(PostgreSqlParser.WITHIN, 0); } + public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } + public TerminalNode WORK() { return getToken(PostgreSqlParser.WORK, 0); } + public TerminalNode WRAPPER() { return getToken(PostgreSqlParser.WRAPPER, 0); } + public TerminalNode WRITE() { return getToken(PostgreSqlParser.WRITE, 0); } + public TerminalNode XML_P() { return getToken(PostgreSqlParser.XML_P, 0); } + public TerminalNode YEAR_P() { return getToken(PostgreSqlParser.YEAR_P, 0); } + public TerminalNode YES_P() { return getToken(PostgreSqlParser.YES_P, 0); } + public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } + public Unreserved_keywordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unreserved_keyword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterUnreserved_keyword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitUnreserved_keyword(this); + } + } + + public final Unreserved_keywordContext unreserved_keyword() throws RecognitionException { + Unreserved_keywordContext _localctx = new Unreserved_keywordContext(_ctx, getState()); + enterRule(_localctx, 1386, RULE_unreserved_keyword); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9897); + _la = _input.LA(1); + if ( !(((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & -31L) != 0) || ((((_la - 190)) & ~0x3f) == 0 && ((1L << (_la - 190)) & -4611686018427387905L) != 0) || ((((_la - 254)) & ~0x3f) == 0 && ((1L << (_la - 254)) & -4503599627370499L) != 0) || ((((_la - 318)) & ~0x3f) == 0 && ((1L << (_la - 318)) & -1L) != 0) || ((((_la - 435)) & ~0x3f) == 0 && ((1L << (_la - 435)) & 72028319537692671L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Col_name_keywordContext extends ParserRuleContext { + public TerminalNode BETWEEN() { return getToken(PostgreSqlParser.BETWEEN, 0); } + public TerminalNode BIGINT() { return getToken(PostgreSqlParser.BIGINT, 0); } + public BitContext bit() { + return getRuleContext(BitContext.class,0); + } + public TerminalNode BOOLEAN_P() { return getToken(PostgreSqlParser.BOOLEAN_P, 0); } + public TerminalNode CHAR_P() { return getToken(PostgreSqlParser.CHAR_P, 0); } + public CharacterContext character() { + return getRuleContext(CharacterContext.class,0); + } + public TerminalNode COALESCE() { return getToken(PostgreSqlParser.COALESCE, 0); } + public TerminalNode DEC() { return getToken(PostgreSqlParser.DEC, 0); } + public TerminalNode DECIMAL_P() { return getToken(PostgreSqlParser.DECIMAL_P, 0); } + public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode EXTRACT() { return getToken(PostgreSqlParser.EXTRACT, 0); } + public TerminalNode FLOAT_P() { return getToken(PostgreSqlParser.FLOAT_P, 0); } + public TerminalNode GREATEST() { return getToken(PostgreSqlParser.GREATEST, 0); } + public TerminalNode GROUPING() { return getToken(PostgreSqlParser.GROUPING, 0); } + public TerminalNode INOUT() { return getToken(PostgreSqlParser.INOUT, 0); } + public TerminalNode INT_P() { return getToken(PostgreSqlParser.INT_P, 0); } + public TerminalNode INTEGER() { return getToken(PostgreSqlParser.INTEGER, 0); } + public TerminalNode INTERVAL() { return getToken(PostgreSqlParser.INTERVAL, 0); } + public TerminalNode LEAST() { return getToken(PostgreSqlParser.LEAST, 0); } + public TerminalNode NATIONAL() { return getToken(PostgreSqlParser.NATIONAL, 0); } + public TerminalNode NCHAR() { return getToken(PostgreSqlParser.NCHAR, 0); } + public TerminalNode NONE() { return getToken(PostgreSqlParser.NONE, 0); } + public TerminalNode NORMALIZE() { return getToken(PostgreSqlParser.NORMALIZE, 0); } + public TerminalNode NULLIF() { return getToken(PostgreSqlParser.NULLIF, 0); } + public NumericContext numeric() { + return getRuleContext(NumericContext.class,0); + } + public TerminalNode OUT_P() { return getToken(PostgreSqlParser.OUT_P, 0); } + public TerminalNode OVERLAY() { return getToken(PostgreSqlParser.OVERLAY, 0); } + public TerminalNode POSITION() { return getToken(PostgreSqlParser.POSITION, 0); } + public TerminalNode PRECISION() { return getToken(PostgreSqlParser.PRECISION, 0); } + public TerminalNode REAL() { return getToken(PostgreSqlParser.REAL, 0); } + public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } + public TerminalNode SETOF() { return getToken(PostgreSqlParser.SETOF, 0); } + public TerminalNode SMALLINT() { return getToken(PostgreSqlParser.SMALLINT, 0); } + public TerminalNode SUBSTRING() { return getToken(PostgreSqlParser.SUBSTRING, 0); } + public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } + public TerminalNode TIMESTAMP() { return getToken(PostgreSqlParser.TIMESTAMP, 0); } + public TerminalNode TREAT() { return getToken(PostgreSqlParser.TREAT, 0); } + public TerminalNode TRIM() { return getToken(PostgreSqlParser.TRIM, 0); } + public TerminalNode VALUES() { return getToken(PostgreSqlParser.VALUES, 0); } + public TerminalNode VARCHAR() { return getToken(PostgreSqlParser.VARCHAR, 0); } + public TerminalNode XMLATTRIBUTES() { return getToken(PostgreSqlParser.XMLATTRIBUTES, 0); } + public TerminalNode XMLCONCAT() { return getToken(PostgreSqlParser.XMLCONCAT, 0); } + public TerminalNode XMLELEMENT() { return getToken(PostgreSqlParser.XMLELEMENT, 0); } + public TerminalNode XMLEXISTS() { return getToken(PostgreSqlParser.XMLEXISTS, 0); } + public TerminalNode XMLFOREST() { return getToken(PostgreSqlParser.XMLFOREST, 0); } + public TerminalNode XMLNAMESPACES() { return getToken(PostgreSqlParser.XMLNAMESPACES, 0); } + public TerminalNode XMLPARSE() { return getToken(PostgreSqlParser.XMLPARSE, 0); } + public TerminalNode XMLPI() { return getToken(PostgreSqlParser.XMLPI, 0); } + public TerminalNode XMLROOT() { return getToken(PostgreSqlParser.XMLROOT, 0); } + public TerminalNode XMLSERIALIZE() { return getToken(PostgreSqlParser.XMLSERIALIZE, 0); } + public TerminalNode XMLTABLE() { return getToken(PostgreSqlParser.XMLTABLE, 0); } + public Builtin_function_nameContext builtin_function_name() { + return getRuleContext(Builtin_function_nameContext.class,0); + } + public Col_name_keywordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_col_name_keyword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCol_name_keyword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCol_name_keyword(this); + } + } + + public final Col_name_keywordContext col_name_keyword() throws RecognitionException { + Col_name_keywordContext _localctx = new Col_name_keywordContext(_ctx, getState()); + enterRule(_localctx, 1388, RULE_col_name_keyword); + try { + setState(9951); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,665,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9899); + match(BETWEEN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9900); + match(BIGINT); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9901); + bit(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9902); + match(BOOLEAN_P); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(9903); + match(CHAR_P); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(9904); + character(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(9905); + match(COALESCE); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(9906); + match(DEC); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(9907); + match(DECIMAL_P); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(9908); + match(EXISTS); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(9909); + match(EXTRACT); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(9910); + match(FLOAT_P); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(9911); + match(GREATEST); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(9912); + match(GROUPING); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(9913); + match(INOUT); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(9914); + match(INT_P); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(9915); + match(INTEGER); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(9916); + match(INTERVAL); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(9917); + match(LEAST); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(9918); + match(NATIONAL); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(9919); + match(NCHAR); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(9920); + match(NONE); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(9921); + match(NORMALIZE); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(9922); + match(NULLIF); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(9923); + numeric(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(9924); + match(OUT_P); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(9925); + match(OVERLAY); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(9926); + match(POSITION); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(9927); + match(PRECISION); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(9928); + match(REAL); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(9929); + match(ROW); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(9930); + match(SETOF); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(9931); + match(SMALLINT); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(9932); + match(SUBSTRING); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(9933); + match(TIME); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(9934); + match(TIMESTAMP); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(9935); + match(TREAT); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(9936); + match(TRIM); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(9937); + match(VALUES); + } + break; + case 40: + enterOuterAlt(_localctx, 40); + { + setState(9938); + match(VARCHAR); + } + break; + case 41: + enterOuterAlt(_localctx, 41); + { + setState(9939); + match(XMLATTRIBUTES); + } + break; + case 42: + enterOuterAlt(_localctx, 42); + { + setState(9940); + match(XMLCONCAT); + } + break; + case 43: + enterOuterAlt(_localctx, 43); + { + setState(9941); + match(XMLELEMENT); + } + break; + case 44: + enterOuterAlt(_localctx, 44); + { + setState(9942); + match(XMLEXISTS); + } + break; + case 45: + enterOuterAlt(_localctx, 45); + { + setState(9943); + match(XMLFOREST); + } + break; + case 46: + enterOuterAlt(_localctx, 46); + { + setState(9944); + match(XMLNAMESPACES); + } + break; + case 47: + enterOuterAlt(_localctx, 47); + { + setState(9945); + match(XMLPARSE); + } + break; + case 48: + enterOuterAlt(_localctx, 48); + { + setState(9946); + match(XMLPI); + } + break; + case 49: + enterOuterAlt(_localctx, 49); + { + setState(9947); + match(XMLROOT); + } + break; + case 50: + enterOuterAlt(_localctx, 50); + { + setState(9948); + match(XMLSERIALIZE); + } + break; + case 51: + enterOuterAlt(_localctx, 51); + { + setState(9949); + match(XMLTABLE); + } + break; + case 52: + enterOuterAlt(_localctx, 52); + { + setState(9950); + builtin_function_name(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Type_func_name_keywordContext extends ParserRuleContext { + public TerminalNode AUTHORIZATION() { return getToken(PostgreSqlParser.AUTHORIZATION, 0); } + public TerminalNode BINARY() { return getToken(PostgreSqlParser.BINARY, 0); } + public TerminalNode COLLATION() { return getToken(PostgreSqlParser.COLLATION, 0); } + public TerminalNode CONCURRENTLY() { return getToken(PostgreSqlParser.CONCURRENTLY, 0); } + public TerminalNode CROSS() { return getToken(PostgreSqlParser.CROSS, 0); } + public TerminalNode CURRENT_SCHEMA() { return getToken(PostgreSqlParser.CURRENT_SCHEMA, 0); } + public TerminalNode FREEZE() { return getToken(PostgreSqlParser.FREEZE, 0); } + public TerminalNode FULL() { return getToken(PostgreSqlParser.FULL, 0); } + public TerminalNode ILIKE() { return getToken(PostgreSqlParser.ILIKE, 0); } + public TerminalNode INNER_P() { return getToken(PostgreSqlParser.INNER_P, 0); } + public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } + public TerminalNode ISNULL() { return getToken(PostgreSqlParser.ISNULL, 0); } + public TerminalNode JOIN() { return getToken(PostgreSqlParser.JOIN, 0); } + public TerminalNode LIKE() { return getToken(PostgreSqlParser.LIKE, 0); } + public TerminalNode NATURAL() { return getToken(PostgreSqlParser.NATURAL, 0); } + public TerminalNode NOTNULL() { return getToken(PostgreSqlParser.NOTNULL, 0); } + public TerminalNode OUTER_P() { return getToken(PostgreSqlParser.OUTER_P, 0); } + public TerminalNode OVERLAPS() { return getToken(PostgreSqlParser.OVERLAPS, 0); } + public TerminalNode SIMILAR() { return getToken(PostgreSqlParser.SIMILAR, 0); } + public TerminalNode TABLESAMPLE() { return getToken(PostgreSqlParser.TABLESAMPLE, 0); } + public TerminalNode VERBOSE() { return getToken(PostgreSqlParser.VERBOSE, 0); } + public Type_func_name_keywordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type_func_name_keyword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterType_func_name_keyword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitType_func_name_keyword(this); + } + } + + public final Type_func_name_keywordContext type_func_name_keyword() throws RecognitionException { + Type_func_name_keywordContext _localctx = new Type_func_name_keywordContext(_ctx, getState()); + enterRule(_localctx, 1390, RULE_type_func_name_keyword); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9953); + _la = _input.LA(1); + if ( !(((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & 7069695L) != 0) || _la==TABLESAMPLE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + @SuppressWarnings("CheckReturnValue") public static class Reserved_keywordContext extends ParserRuleContext { + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode ANALYSE() { return getToken(PostgreSqlParser.ANALYSE, 0); } + public TerminalNode ANALYZE() { return getToken(PostgreSqlParser.ANALYZE, 0); } + public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } + public TerminalNode ANY() { return getToken(PostgreSqlParser.ANY, 0); } + public TerminalNode ARRAY() { return getToken(PostgreSqlParser.ARRAY, 0); } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode ASC() { return getToken(PostgreSqlParser.ASC, 0); } + public TerminalNode ASYMMETRIC() { return getToken(PostgreSqlParser.ASYMMETRIC, 0); } + public TerminalNode BOTH() { return getToken(PostgreSqlParser.BOTH, 0); } + public TerminalNode CASE() { return getToken(PostgreSqlParser.CASE, 0); } + public TerminalNode CAST() { return getToken(PostgreSqlParser.CAST, 0); } + public TerminalNode CHECK() { return getToken(PostgreSqlParser.CHECK, 0); } + public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } + public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } public TerminalNode CREATE() { return getToken(PostgreSqlParser.CREATE, 0); } - public TerminalNode DROP() { return getToken(PostgreSqlParser.DROP, 0); } + public TerminalNode CURRENT_CATALOG() { return getToken(PostgreSqlParser.CURRENT_CATALOG, 0); } + public TerminalNode CURRENT_DATE() { return getToken(PostgreSqlParser.CURRENT_DATE, 0); } + public TerminalNode CURRENT_ROLE() { return getToken(PostgreSqlParser.CURRENT_ROLE, 0); } + public TerminalNode CURRENT_TIME() { return getToken(PostgreSqlParser.CURRENT_TIME, 0); } + public TerminalNode CURRENT_TIMESTAMP() { return getToken(PostgreSqlParser.CURRENT_TIMESTAMP, 0); } + public TerminalNode CURRENT_USER() { return getToken(PostgreSqlParser.CURRENT_USER, 0); } + public TerminalNode DEFERRABLE() { return getToken(PostgreSqlParser.DEFERRABLE, 0); } + public TerminalNode DESC() { return getToken(PostgreSqlParser.DESC, 0); } + public TerminalNode DISTINCT() { return getToken(PostgreSqlParser.DISTINCT, 0); } + public TerminalNode DO() { return getToken(PostgreSqlParser.DO, 0); } + public TerminalNode ELSE() { return getToken(PostgreSqlParser.ELSE, 0); } + public TerminalNode END_P() { return getToken(PostgreSqlParser.END_P, 0); } + public TerminalNode EXCEPT() { return getToken(PostgreSqlParser.EXCEPT, 0); } + public TerminalNode FALSE_P() { return getToken(PostgreSqlParser.FALSE_P, 0); } + public TerminalNode FETCH() { return getToken(PostgreSqlParser.FETCH, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public TerminalNode FOREIGN() { return getToken(PostgreSqlParser.FOREIGN, 0); } public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } - public TerminalNode GROUP() { return getToken(PostgreSqlParser.GROUP, 0); } + public TerminalNode GRANT() { return getToken(PostgreSqlParser.GRANT, 0); } + public TerminalNode GROUP_P() { return getToken(PostgreSqlParser.GROUP_P, 0); } + public TerminalNode HAVING() { return getToken(PostgreSqlParser.HAVING, 0); } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public TerminalNode INITIALLY() { return getToken(PostgreSqlParser.INITIALLY, 0); } + public TerminalNode INTERSECT() { return getToken(PostgreSqlParser.INTERSECT, 0); } + public TerminalNode LATERAL_P() { return getToken(PostgreSqlParser.LATERAL_P, 0); } + public TerminalNode LEADING() { return getToken(PostgreSqlParser.LEADING, 0); } public TerminalNode LIMIT() { return getToken(PostgreSqlParser.LIMIT, 0); } + public TerminalNode LOCALTIME() { return getToken(PostgreSqlParser.LOCALTIME, 0); } + public TerminalNode LOCALTIMESTAMP() { return getToken(PostgreSqlParser.LOCALTIMESTAMP, 0); } + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode OFFSET() { return getToken(PostgreSqlParser.OFFSET, 0); } + public TerminalNode ON() { return getToken(PostgreSqlParser.ON, 0); } + public TerminalNode ONLY() { return getToken(PostgreSqlParser.ONLY, 0); } + public TerminalNode OR() { return getToken(PostgreSqlParser.OR, 0); } public TerminalNode ORDER() { return getToken(PostgreSqlParser.ORDER, 0); } + public TerminalNode PLACING() { return getToken(PostgreSqlParser.PLACING, 0); } + public TerminalNode PRIMARY() { return getToken(PostgreSqlParser.PRIMARY, 0); } + public TerminalNode REFERENCES() { return getToken(PostgreSqlParser.REFERENCES, 0); } + public TerminalNode RETURNING() { return getToken(PostgreSqlParser.RETURNING, 0); } public TerminalNode SELECT() { return getToken(PostgreSqlParser.SELECT, 0); } + public TerminalNode SESSION_USER() { return getToken(PostgreSqlParser.SESSION_USER, 0); } + public TerminalNode SOME() { return getToken(PostgreSqlParser.SOME, 0); } + public TerminalNode SYMMETRIC() { return getToken(PostgreSqlParser.SYMMETRIC, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public TerminalNode THEN() { return getToken(PostgreSqlParser.THEN, 0); } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public TerminalNode TRAILING() { return getToken(PostgreSqlParser.TRAILING, 0); } + public TerminalNode TRUE_P() { return getToken(PostgreSqlParser.TRUE_P, 0); } public TerminalNode UNION() { return getToken(PostgreSqlParser.UNION, 0); } + public TerminalNode UNIQUE() { return getToken(PostgreSqlParser.UNIQUE, 0); } + public TerminalNode USER() { return getToken(PostgreSqlParser.USER, 0); } + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public TerminalNode VARIADIC() { return getToken(PostgreSqlParser.VARIADIC, 0); } + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public TerminalNode WHERE() { return getToken(PostgreSqlParser.WHERE, 0); } + public TerminalNode WINDOW() { return getToken(PostgreSqlParser.WINDOW, 0); } + public TerminalNode WITH() { return getToken(PostgreSqlParser.WITH, 0); } public Reserved_keywordContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -47435,14 +87982,14 @@ public class PostgreSqlParser extends Parser { public final Reserved_keywordContext reserved_keyword() throws RecognitionException { Reserved_keywordContext _localctx = new Reserved_keywordContext(_ctx, getState()); - enterRule(_localctx, 524, RULE_reserved_keyword); + enterRule(_localctx, 1392, RULE_reserved_keyword); int _la; try { enterOuterAlt(_localctx, 1); { - setState(5676); + setState(9955); _la = _input.LA(1); - if ( !(_la==CREATE || _la==DROP || _la==FROM || _la==GROUP || _la==LIMIT || _la==ORDER || _la==SELECT || _la==UNION) ) { + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028801313931264L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 17592186043903L) != 0) || _la==END_P) ) { _errHandler.recoverInline(this); } else { @@ -47464,537 +88011,156 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Non_reserved_keywordContext extends ParserRuleContext { - public TerminalNode A_() { return getToken(PostgreSqlParser.A_, 0); } - public TerminalNode ABORT() { return getToken(PostgreSqlParser.ABORT, 0); } + public static class Builtin_function_nameContext extends ParserRuleContext { + public TerminalNode XMLCOMMENT() { return getToken(PostgreSqlParser.XMLCOMMENT, 0); } + public TerminalNode XML_IS_WELL_FORMED() { return getToken(PostgreSqlParser.XML_IS_WELL_FORMED, 0); } + public TerminalNode XML_IS_WELL_FORMED_DOCUMENT() { return getToken(PostgreSqlParser.XML_IS_WELL_FORMED_DOCUMENT, 0); } + public TerminalNode XML_IS_WELL_FORMED_CONTENT() { return getToken(PostgreSqlParser.XML_IS_WELL_FORMED_CONTENT, 0); } + public TerminalNode XMLAGG() { return getToken(PostgreSqlParser.XMLAGG, 0); } + public TerminalNode XPATH() { return getToken(PostgreSqlParser.XPATH, 0); } + public TerminalNode XPATH_EXISTS() { return getToken(PostgreSqlParser.XPATH_EXISTS, 0); } public TerminalNode ABS() { return getToken(PostgreSqlParser.ABS, 0); } - public TerminalNode ABSOLUTE() { return getToken(PostgreSqlParser.ABSOLUTE, 0); } - public TerminalNode ACCESS() { return getToken(PostgreSqlParser.ACCESS, 0); } - public TerminalNode ACTION() { return getToken(PostgreSqlParser.ACTION, 0); } - public TerminalNode ADA() { return getToken(PostgreSqlParser.ADA, 0); } - public TerminalNode ADD() { return getToken(PostgreSqlParser.ADD, 0); } - public TerminalNode ADMIN() { return getToken(PostgreSqlParser.ADMIN, 0); } - public TerminalNode AFTER() { return getToken(PostgreSqlParser.AFTER, 0); } - public TerminalNode AGGREGATE() { return getToken(PostgreSqlParser.AGGREGATE, 0); } - public TerminalNode ALLOCATE() { return getToken(PostgreSqlParser.ALLOCATE, 0); } - public TerminalNode ALSO() { return getToken(PostgreSqlParser.ALSO, 0); } - public TerminalNode ALTER() { return getToken(PostgreSqlParser.ALTER, 0); } - public TerminalNode ALWAYS() { return getToken(PostgreSqlParser.ALWAYS, 0); } - public TerminalNode ANY() { return getToken(PostgreSqlParser.ANY, 0); } - public TerminalNode ARE() { return getToken(PostgreSqlParser.ARE, 0); } - public TerminalNode ASENSITIVE() { return getToken(PostgreSqlParser.ASENSITIVE, 0); } - public TerminalNode ASSERTION() { return getToken(PostgreSqlParser.ASSERTION, 0); } - public TerminalNode ASSIGNMENT() { return getToken(PostgreSqlParser.ASSIGNMENT, 0); } - public TerminalNode AT() { return getToken(PostgreSqlParser.AT, 0); } - public TerminalNode ATOMIC() { return getToken(PostgreSqlParser.ATOMIC, 0); } - public TerminalNode ATTRIBUTE() { return getToken(PostgreSqlParser.ATTRIBUTE, 0); } - public TerminalNode ATTRIBUTES() { return getToken(PostgreSqlParser.ATTRIBUTES, 0); } - public TerminalNode AVG() { return getToken(PostgreSqlParser.AVG, 0); } - public TerminalNode BACKWARD() { return getToken(PostgreSqlParser.BACKWARD, 0); } - public TerminalNode BEFORE() { return getToken(PostgreSqlParser.BEFORE, 0); } - public TerminalNode BEGIN() { return getToken(PostgreSqlParser.BEGIN, 0); } - public TerminalNode BERNOULLI() { return getToken(PostgreSqlParser.BERNOULLI, 0); } - public TerminalNode BETWEEN() { return getToken(PostgreSqlParser.BETWEEN, 0); } - public TerminalNode BIGINT() { return getToken(PostgreSqlParser.BIGINT, 0); } - public TerminalNode BIT() { return getToken(PostgreSqlParser.BIT, 0); } - public TerminalNode BIT_LENGTH() { return getToken(PostgreSqlParser.BIT_LENGTH, 0); } - public TerminalNode BLOB() { return getToken(PostgreSqlParser.BLOB, 0); } - public TerminalNode BOOLEAN() { return getToken(PostgreSqlParser.BOOLEAN, 0); } - public TerminalNode BREADTH() { return getToken(PostgreSqlParser.BREADTH, 0); } - public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } - public TerminalNode C_() { return getToken(PostgreSqlParser.C_, 0); } - public TerminalNode CACHE() { return getToken(PostgreSqlParser.CACHE, 0); } - public TerminalNode CALL() { return getToken(PostgreSqlParser.CALL, 0); } - public TerminalNode CALLED() { return getToken(PostgreSqlParser.CALLED, 0); } - public TerminalNode CARDINALITY() { return getToken(PostgreSqlParser.CARDINALITY, 0); } - public TerminalNode CASCADE() { return getToken(PostgreSqlParser.CASCADE, 0); } - public TerminalNode CASCADED() { return getToken(PostgreSqlParser.CASCADED, 0); } - public TerminalNode CATALOG() { return getToken(PostgreSqlParser.CATALOG, 0); } - public TerminalNode CATALOG_NAME() { return getToken(PostgreSqlParser.CATALOG_NAME, 0); } + public TerminalNode CBRT() { return getToken(PostgreSqlParser.CBRT, 0); } public TerminalNode CEIL() { return getToken(PostgreSqlParser.CEIL, 0); } public TerminalNode CEILING() { return getToken(PostgreSqlParser.CEILING, 0); } - public TerminalNode CHAIN() { return getToken(PostgreSqlParser.CHAIN, 0); } - public TerminalNode CHAR() { return getToken(PostgreSqlParser.CHAR, 0); } - public TerminalNode CHARACTER() { return getToken(PostgreSqlParser.CHARACTER, 0); } - public TerminalNode CHARACTERISTICS() { return getToken(PostgreSqlParser.CHARACTERISTICS, 0); } - public TerminalNode CHARACTERS() { return getToken(PostgreSqlParser.CHARACTERS, 0); } - public TerminalNode CHARACTER_LENGTH() { return getToken(PostgreSqlParser.CHARACTER_LENGTH, 0); } - public TerminalNode CHARACTER_SET_CATALOG() { return getToken(PostgreSqlParser.CHARACTER_SET_CATALOG, 0); } - public TerminalNode CHARACTER_SET_NAME() { return getToken(PostgreSqlParser.CHARACTER_SET_NAME, 0); } - public TerminalNode CHARACTER_SET_SCHEMA() { return getToken(PostgreSqlParser.CHARACTER_SET_SCHEMA, 0); } - public TerminalNode CHAR_LENGTH() { return getToken(PostgreSqlParser.CHAR_LENGTH, 0); } - public TerminalNode CHECKPOINT() { return getToken(PostgreSqlParser.CHECKPOINT, 0); } - public TerminalNode CLASS() { return getToken(PostgreSqlParser.CLASS, 0); } - public TerminalNode CLASS_ORIGIN() { return getToken(PostgreSqlParser.CLASS_ORIGIN, 0); } - public TerminalNode CLOB() { return getToken(PostgreSqlParser.CLOB, 0); } - public TerminalNode CLOSE() { return getToken(PostgreSqlParser.CLOSE, 0); } - public TerminalNode CLUSTER() { return getToken(PostgreSqlParser.CLUSTER, 0); } - public TerminalNode COALESCE() { return getToken(PostgreSqlParser.COALESCE, 0); } - public TerminalNode COBOL() { return getToken(PostgreSqlParser.COBOL, 0); } - public TerminalNode COLLATION_CATALOG() { return getToken(PostgreSqlParser.COLLATION_CATALOG, 0); } - public TerminalNode COLLATION_NAME() { return getToken(PostgreSqlParser.COLLATION_NAME, 0); } - public TerminalNode COLLATION_SCHEMA() { return getToken(PostgreSqlParser.COLLATION_SCHEMA, 0); } - public TerminalNode COLLECT() { return getToken(PostgreSqlParser.COLLECT, 0); } - public TerminalNode COLUMN_NAME() { return getToken(PostgreSqlParser.COLUMN_NAME, 0); } - public TerminalNode COMMAND_FUNCTION() { return getToken(PostgreSqlParser.COMMAND_FUNCTION, 0); } - public TerminalNode COMMAND_FUNCTION_CODE() { return getToken(PostgreSqlParser.COMMAND_FUNCTION_CODE, 0); } - public TerminalNode COMMENT() { return getToken(PostgreSqlParser.COMMENT, 0); } - public TerminalNode COMMIT() { return getToken(PostgreSqlParser.COMMIT, 0); } - public TerminalNode COMMITTED() { return getToken(PostgreSqlParser.COMMITTED, 0); } - public TerminalNode CONDITION() { return getToken(PostgreSqlParser.CONDITION, 0); } - public TerminalNode CONDITION_NUMBER() { return getToken(PostgreSqlParser.CONDITION_NUMBER, 0); } - public TerminalNode CONNECT() { return getToken(PostgreSqlParser.CONNECT, 0); } - public TerminalNode CONNECTION() { return getToken(PostgreSqlParser.CONNECTION, 0); } - public TerminalNode CONNECTION_NAME() { return getToken(PostgreSqlParser.CONNECTION_NAME, 0); } - public TerminalNode CONSTRAINTS() { return getToken(PostgreSqlParser.CONSTRAINTS, 0); } - public TerminalNode CONSTRAINT_CATALOG() { return getToken(PostgreSqlParser.CONSTRAINT_CATALOG, 0); } - public TerminalNode CONSTRAINT_NAME() { return getToken(PostgreSqlParser.CONSTRAINT_NAME, 0); } - public TerminalNode CONSTRAINT_SCHEMA() { return getToken(PostgreSqlParser.CONSTRAINT_SCHEMA, 0); } - public TerminalNode CONSTRUCTOR() { return getToken(PostgreSqlParser.CONSTRUCTOR, 0); } - public TerminalNode CONTAINS() { return getToken(PostgreSqlParser.CONTAINS, 0); } - public TerminalNode CONTINUE() { return getToken(PostgreSqlParser.CONTINUE, 0); } - public TerminalNode CONVERSION() { return getToken(PostgreSqlParser.CONVERSION, 0); } - public TerminalNode CONVERT() { return getToken(PostgreSqlParser.CONVERT, 0); } - public TerminalNode COPY() { return getToken(PostgreSqlParser.COPY, 0); } - public TerminalNode CORR() { return getToken(PostgreSqlParser.CORR, 0); } - public TerminalNode CORRESPONDING() { return getToken(PostgreSqlParser.CORRESPONDING, 0); } - public TerminalNode COUNT() { return getToken(PostgreSqlParser.COUNT, 0); } - public TerminalNode COVAR_POP() { return getToken(PostgreSqlParser.COVAR_POP, 0); } - public TerminalNode COVAR_SAMP() { return getToken(PostgreSqlParser.COVAR_SAMP, 0); } - public TerminalNode CSV() { return getToken(PostgreSqlParser.CSV, 0); } - public TerminalNode CUBE() { return getToken(PostgreSqlParser.CUBE, 0); } - public TerminalNode CUME_DIST() { return getToken(PostgreSqlParser.CUME_DIST, 0); } - public TerminalNode CURRENT() { return getToken(PostgreSqlParser.CURRENT, 0); } - public TerminalNode CURRENT_DEFAULT_TRANSFORM_GROUP() { return getToken(PostgreSqlParser.CURRENT_DEFAULT_TRANSFORM_GROUP, 0); } - public TerminalNode CURRENT_PATH() { return getToken(PostgreSqlParser.CURRENT_PATH, 0); } - public TerminalNode CURRENT_TRANSFORM_GROUP_FOR_TYPE() { return getToken(PostgreSqlParser.CURRENT_TRANSFORM_GROUP_FOR_TYPE, 0); } - public TerminalNode CURSOR() { return getToken(PostgreSqlParser.CURSOR, 0); } - public TerminalNode CURSOR_NAME() { return getToken(PostgreSqlParser.CURSOR_NAME, 0); } - public TerminalNode CYCLE() { return getToken(PostgreSqlParser.CYCLE, 0); } - public TerminalNode DATA() { return getToken(PostgreSqlParser.DATA, 0); } - public TerminalNode DATABASE() { return getToken(PostgreSqlParser.DATABASE, 0); } - public TerminalNode DATE() { return getToken(PostgreSqlParser.DATE, 0); } - public TerminalNode DATETIME_INTERVAL_CODE() { return getToken(PostgreSqlParser.DATETIME_INTERVAL_CODE, 0); } - public TerminalNode DATETIME_INTERVAL_PRECISION() { return getToken(PostgreSqlParser.DATETIME_INTERVAL_PRECISION, 0); } - public TerminalNode DAY() { return getToken(PostgreSqlParser.DAY, 0); } - public TerminalNode DEALLOCATE() { return getToken(PostgreSqlParser.DEALLOCATE, 0); } - public TerminalNode DEC() { return getToken(PostgreSqlParser.DEC, 0); } - public TerminalNode DECIMAL() { return getToken(PostgreSqlParser.DECIMAL, 0); } - public TerminalNode DECLARE() { return getToken(PostgreSqlParser.DECLARE, 0); } - public TerminalNode DEFAULTS() { return getToken(PostgreSqlParser.DEFAULTS, 0); } - public TerminalNode DEFERRED() { return getToken(PostgreSqlParser.DEFERRED, 0); } - public TerminalNode DEFINED() { return getToken(PostgreSqlParser.DEFINED, 0); } - public TerminalNode DEFINER() { return getToken(PostgreSqlParser.DEFINER, 0); } - public TerminalNode DEGREE() { return getToken(PostgreSqlParser.DEGREE, 0); } - public TerminalNode DELETE() { return getToken(PostgreSqlParser.DELETE, 0); } - public TerminalNode DELIMITER() { return getToken(PostgreSqlParser.DELIMITER, 0); } - public TerminalNode DELIMITERS() { return getToken(PostgreSqlParser.DELIMITERS, 0); } - public TerminalNode DENSE_RANK() { return getToken(PostgreSqlParser.DENSE_RANK, 0); } - public TerminalNode DEPTH() { return getToken(PostgreSqlParser.DEPTH, 0); } - public TerminalNode DEREF() { return getToken(PostgreSqlParser.DEREF, 0); } - public TerminalNode DERIVED() { return getToken(PostgreSqlParser.DERIVED, 0); } - public TerminalNode DESCRIBE() { return getToken(PostgreSqlParser.DESCRIBE, 0); } - public TerminalNode DESCRIPTOR() { return getToken(PostgreSqlParser.DESCRIPTOR, 0); } - public TerminalNode DETERMINISTIC() { return getToken(PostgreSqlParser.DETERMINISTIC, 0); } - public TerminalNode DIAGNOSTICS() { return getToken(PostgreSqlParser.DIAGNOSTICS, 0); } - public TerminalNode DICTIONARY() { return getToken(PostgreSqlParser.DICTIONARY, 0); } - public TerminalNode DISCONNECT() { return getToken(PostgreSqlParser.DISCONNECT, 0); } - public TerminalNode DISPATCH() { return getToken(PostgreSqlParser.DISPATCH, 0); } - public TerminalNode DOMAIN() { return getToken(PostgreSqlParser.DOMAIN, 0); } - public TerminalNode DOUBLE() { return getToken(PostgreSqlParser.DOUBLE, 0); } - public TerminalNode DYNAMIC() { return getToken(PostgreSqlParser.DYNAMIC, 0); } - public TerminalNode DYNAMIC_FUNCTION() { return getToken(PostgreSqlParser.DYNAMIC_FUNCTION, 0); } - public TerminalNode DYNAMIC_FUNCTION_CODE() { return getToken(PostgreSqlParser.DYNAMIC_FUNCTION_CODE, 0); } - public TerminalNode EACH() { return getToken(PostgreSqlParser.EACH, 0); } - public TerminalNode ELEMENT() { return getToken(PostgreSqlParser.ELEMENT, 0); } - public TerminalNode ENCODING() { return getToken(PostgreSqlParser.ENCODING, 0); } - public TerminalNode ENCRYPTED() { return getToken(PostgreSqlParser.ENCRYPTED, 0); } - public TerminalNode END() { return getToken(PostgreSqlParser.END, 0); } - public TerminalNode EQUALS() { return getToken(PostgreSqlParser.EQUALS, 0); } - public TerminalNode ESCAPE() { return getToken(PostgreSqlParser.ESCAPE, 0); } - public TerminalNode EVERY() { return getToken(PostgreSqlParser.EVERY, 0); } - public TerminalNode EXCEPTION() { return getToken(PostgreSqlParser.EXCEPTION, 0); } - public TerminalNode EXCLUDE() { return getToken(PostgreSqlParser.EXCLUDE, 0); } - public TerminalNode EXCLUDING() { return getToken(PostgreSqlParser.EXCLUDING, 0); } - public TerminalNode EXCLUSIVE() { return getToken(PostgreSqlParser.EXCLUSIVE, 0); } - public TerminalNode EXEC() { return getToken(PostgreSqlParser.EXEC, 0); } - public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } - public TerminalNode EXISTS() { return getToken(PostgreSqlParser.EXISTS, 0); } + public TerminalNode DEGREES() { return getToken(PostgreSqlParser.DEGREES, 0); } + public TerminalNode DIV() { return getToken(PostgreSqlParser.DIV, 0); } public TerminalNode EXP() { return getToken(PostgreSqlParser.EXP, 0); } - public TerminalNode EXPLAIN() { return getToken(PostgreSqlParser.EXPLAIN, 0); } - public TerminalNode EXTENSION() { return getToken(PostgreSqlParser.EXTENSION, 0); } - public TerminalNode EXTERNAL() { return getToken(PostgreSqlParser.EXTERNAL, 0); } - public TerminalNode EXTRACT() { return getToken(PostgreSqlParser.EXTRACT, 0); } - public TerminalNode FILTER() { return getToken(PostgreSqlParser.FILTER, 0); } - public TerminalNode FINAL() { return getToken(PostgreSqlParser.FINAL, 0); } - public TerminalNode FIRST() { return getToken(PostgreSqlParser.FIRST, 0); } - public TerminalNode FLOAT() { return getToken(PostgreSqlParser.FLOAT, 0); } + public TerminalNode FACTORIAL() { return getToken(PostgreSqlParser.FACTORIAL, 0); } public TerminalNode FLOOR() { return getToken(PostgreSqlParser.FLOOR, 0); } - public TerminalNode FOLLOWING() { return getToken(PostgreSqlParser.FOLLOWING, 0); } - public TerminalNode FORCE() { return getToken(PostgreSqlParser.FORCE, 0); } - public TerminalNode FORMAT() { return getToken(PostgreSqlParser.FORMAT, 0); } - public TerminalNode FORTRAN() { return getToken(PostgreSqlParser.FORTRAN, 0); } - public TerminalNode FORWARD() { return getToken(PostgreSqlParser.FORWARD, 0); } - public TerminalNode FOUND() { return getToken(PostgreSqlParser.FOUND, 0); } - public TerminalNode FREE() { return getToken(PostgreSqlParser.FREE, 0); } - public TerminalNode FUNCTION() { return getToken(PostgreSqlParser.FUNCTION, 0); } - public TerminalNode FUSION() { return getToken(PostgreSqlParser.FUSION, 0); } - public TerminalNode G_() { return getToken(PostgreSqlParser.G_, 0); } - public TerminalNode GENERAL() { return getToken(PostgreSqlParser.GENERAL, 0); } - public TerminalNode GENERATED() { return getToken(PostgreSqlParser.GENERATED, 0); } - public TerminalNode GET() { return getToken(PostgreSqlParser.GET, 0); } - public TerminalNode GLOBAL() { return getToken(PostgreSqlParser.GLOBAL, 0); } - public TerminalNode GO() { return getToken(PostgreSqlParser.GO, 0); } - public TerminalNode GOTO() { return getToken(PostgreSqlParser.GOTO, 0); } - public TerminalNode GREATEST() { return getToken(PostgreSqlParser.GREATEST, 0); } - public TerminalNode GRANTED() { return getToken(PostgreSqlParser.GRANTED, 0); } - public TerminalNode GROUPING() { return getToken(PostgreSqlParser.GROUPING, 0); } - public TerminalNode HANDLER() { return getToken(PostgreSqlParser.HANDLER, 0); } - public TerminalNode HIERARCHY() { return getToken(PostgreSqlParser.HIERARCHY, 0); } - public TerminalNode HOLD() { return getToken(PostgreSqlParser.HOLD, 0); } - public TerminalNode HOST() { return getToken(PostgreSqlParser.HOST, 0); } - public TerminalNode HOUR() { return getToken(PostgreSqlParser.HOUR, 0); } - public TerminalNode IDENTITY() { return getToken(PostgreSqlParser.IDENTITY, 0); } - public TerminalNode IGNORE() { return getToken(PostgreSqlParser.IGNORE, 0); } - public TerminalNode IMMEDIATE() { return getToken(PostgreSqlParser.IMMEDIATE, 0); } - public TerminalNode IMMUTABLE() { return getToken(PostgreSqlParser.IMMUTABLE, 0); } - public TerminalNode IMPLEMENTATION() { return getToken(PostgreSqlParser.IMPLEMENTATION, 0); } - public TerminalNode IMPLICIT() { return getToken(PostgreSqlParser.IMPLICIT, 0); } - public TerminalNode INCLUDING() { return getToken(PostgreSqlParser.INCLUDING, 0); } - public TerminalNode INCREMENT() { return getToken(PostgreSqlParser.INCREMENT, 0); } - public TerminalNode INDEX() { return getToken(PostgreSqlParser.INDEX, 0); } - public TerminalNode INDICATOR() { return getToken(PostgreSqlParser.INDICATOR, 0); } - public TerminalNode INHERITS() { return getToken(PostgreSqlParser.INHERITS, 0); } - public TerminalNode INOUT() { return getToken(PostgreSqlParser.INOUT, 0); } - public TerminalNode INPUT() { return getToken(PostgreSqlParser.INPUT, 0); } - public TerminalNode INSENSITIVE() { return getToken(PostgreSqlParser.INSENSITIVE, 0); } - public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } - public TerminalNode INSTANCE() { return getToken(PostgreSqlParser.INSTANCE, 0); } - public TerminalNode INSTANTIABLE() { return getToken(PostgreSqlParser.INSTANTIABLE, 0); } - public TerminalNode INSTEAD() { return getToken(PostgreSqlParser.INSTEAD, 0); } - public TerminalNode INT() { return getToken(PostgreSqlParser.INT, 0); } - public TerminalNode INTEGER() { return getToken(PostgreSqlParser.INTEGER, 0); } - public TerminalNode INTERSECTION() { return getToken(PostgreSqlParser.INTERSECTION, 0); } - public TerminalNode INTERVAL() { return getToken(PostgreSqlParser.INTERVAL, 0); } - public TerminalNode INVOKER() { return getToken(PostgreSqlParser.INVOKER, 0); } - public TerminalNode ISOLATION() { return getToken(PostgreSqlParser.ISOLATION, 0); } - public TerminalNode K_() { return getToken(PostgreSqlParser.K_, 0); } - public TerminalNode KEY() { return getToken(PostgreSqlParser.KEY, 0); } - public TerminalNode KEY_MEMBER() { return getToken(PostgreSqlParser.KEY_MEMBER, 0); } - public TerminalNode KEY_TYPE() { return getToken(PostgreSqlParser.KEY_TYPE, 0); } - public TerminalNode LANGUAGE() { return getToken(PostgreSqlParser.LANGUAGE, 0); } - public TerminalNode LARGE() { return getToken(PostgreSqlParser.LARGE, 0); } - public TerminalNode LAST() { return getToken(PostgreSqlParser.LAST, 0); } - public TerminalNode LEAST() { return getToken(PostgreSqlParser.LEAST, 0); } - public TerminalNode LEFT() { return getToken(PostgreSqlParser.LEFT, 0); } - public TerminalNode LENGTH() { return getToken(PostgreSqlParser.LENGTH, 0); } - public TerminalNode LEVEL() { return getToken(PostgreSqlParser.LEVEL, 0); } - public TerminalNode LISTEN() { return getToken(PostgreSqlParser.LISTEN, 0); } + public TerminalNode GCD() { return getToken(PostgreSqlParser.GCD, 0); } + public TerminalNode LCM() { return getToken(PostgreSqlParser.LCM, 0); } public TerminalNode LN() { return getToken(PostgreSqlParser.LN, 0); } - public TerminalNode LOAD() { return getToken(PostgreSqlParser.LOAD, 0); } - public TerminalNode LOCAL() { return getToken(PostgreSqlParser.LOCAL, 0); } - public TerminalNode LOCATION() { return getToken(PostgreSqlParser.LOCATION, 0); } - public TerminalNode LOCATOR() { return getToken(PostgreSqlParser.LOCATOR, 0); } - public TerminalNode LOCK() { return getToken(PostgreSqlParser.LOCK, 0); } - public TerminalNode LOCKED() { return getToken(PostgreSqlParser.LOCKED, 0); } - public TerminalNode LOWER() { return getToken(PostgreSqlParser.LOWER, 0); } - public TerminalNode M_() { return getToken(PostgreSqlParser.M_, 0); } - public TerminalNode MAP() { return getToken(PostgreSqlParser.MAP, 0); } - public TerminalNode MATCH() { return getToken(PostgreSqlParser.MATCH, 0); } - public TerminalNode MATCHED() { return getToken(PostgreSqlParser.MATCHED, 0); } - public TerminalNode MAX() { return getToken(PostgreSqlParser.MAX, 0); } - public TerminalNode MAXVALUE() { return getToken(PostgreSqlParser.MAXVALUE, 0); } - public TerminalNode MEMBER() { return getToken(PostgreSqlParser.MEMBER, 0); } - public TerminalNode MERGE() { return getToken(PostgreSqlParser.MERGE, 0); } - public TerminalNode MESSAGE_LENGTH() { return getToken(PostgreSqlParser.MESSAGE_LENGTH, 0); } - public TerminalNode MESSAGE_OCTET_LENGTH() { return getToken(PostgreSqlParser.MESSAGE_OCTET_LENGTH, 0); } - public TerminalNode MESSAGE_TEXT() { return getToken(PostgreSqlParser.MESSAGE_TEXT, 0); } - public TerminalNode METHOD() { return getToken(PostgreSqlParser.METHOD, 0); } - public TerminalNode MIN() { return getToken(PostgreSqlParser.MIN, 0); } - public TerminalNode MINUTE() { return getToken(PostgreSqlParser.MINUTE, 0); } - public TerminalNode MINVALUE() { return getToken(PostgreSqlParser.MINVALUE, 0); } + public TerminalNode LOG() { return getToken(PostgreSqlParser.LOG, 0); } + public TerminalNode LOG10() { return getToken(PostgreSqlParser.LOG10, 0); } + public TerminalNode MIN_SCALE() { return getToken(PostgreSqlParser.MIN_SCALE, 0); } public TerminalNode MOD() { return getToken(PostgreSqlParser.MOD, 0); } - public TerminalNode MODE() { return getToken(PostgreSqlParser.MODE, 0); } - public TerminalNode MODIFIES() { return getToken(PostgreSqlParser.MODIFIES, 0); } - public TerminalNode MODULE() { return getToken(PostgreSqlParser.MODULE, 0); } - public TerminalNode MONTH() { return getToken(PostgreSqlParser.MONTH, 0); } - public TerminalNode MORE_() { return getToken(PostgreSqlParser.MORE_, 0); } - public TerminalNode MOVE() { return getToken(PostgreSqlParser.MOVE, 0); } - public TerminalNode MULTISET() { return getToken(PostgreSqlParser.MULTISET, 0); } - public TerminalNode MUMPS() { return getToken(PostgreSqlParser.MUMPS, 0); } - public TerminalNode NAME() { return getToken(PostgreSqlParser.NAME, 0); } - public TerminalNode NAMES() { return getToken(PostgreSqlParser.NAMES, 0); } - public TerminalNode NATIONAL() { return getToken(PostgreSqlParser.NATIONAL, 0); } - public TerminalNode NCHAR() { return getToken(PostgreSqlParser.NCHAR, 0); } - public TerminalNode NCLOB() { return getToken(PostgreSqlParser.NCLOB, 0); } - public TerminalNode NESTING() { return getToken(PostgreSqlParser.NESTING, 0); } - public TerminalNode NEW() { return getToken(PostgreSqlParser.NEW, 0); } - public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } - public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } - public TerminalNode NONE() { return getToken(PostgreSqlParser.NONE, 0); } - public TerminalNode NORMALIZE() { return getToken(PostgreSqlParser.NORMALIZE, 0); } - public TerminalNode NORMALIZED() { return getToken(PostgreSqlParser.NORMALIZED, 0); } - public TerminalNode NOTHING() { return getToken(PostgreSqlParser.NOTHING, 0); } - public TerminalNode NOTIFY() { return getToken(PostgreSqlParser.NOTIFY, 0); } - public TerminalNode NOWAIT() { return getToken(PostgreSqlParser.NOWAIT, 0); } - public TerminalNode NULLABLE() { return getToken(PostgreSqlParser.NULLABLE, 0); } - public TerminalNode NULLIF() { return getToken(PostgreSqlParser.NULLIF, 0); } - public TerminalNode NULLS() { return getToken(PostgreSqlParser.NULLS, 0); } - public TerminalNode NUMBER() { return getToken(PostgreSqlParser.NUMBER, 0); } - public TerminalNode NUMERIC() { return getToken(PostgreSqlParser.NUMERIC, 0); } - public TerminalNode OBJECT() { return getToken(PostgreSqlParser.OBJECT, 0); } - public TerminalNode OCTETS() { return getToken(PostgreSqlParser.OCTETS, 0); } - public TerminalNode OCTET_LENGTH() { return getToken(PostgreSqlParser.OCTET_LENGTH, 0); } - public TerminalNode OF() { return getToken(PostgreSqlParser.OF, 0); } - public TerminalNode OFF() { return getToken(PostgreSqlParser.OFF, 0); } - public TerminalNode OIDS() { return getToken(PostgreSqlParser.OIDS, 0); } - public TerminalNode OLD() { return getToken(PostgreSqlParser.OLD, 0); } - public TerminalNode OPEN() { return getToken(PostgreSqlParser.OPEN, 0); } - public TerminalNode OPERATOR() { return getToken(PostgreSqlParser.OPERATOR, 0); } - public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } - public TerminalNode OPTIONS() { return getToken(PostgreSqlParser.OPTIONS, 0); } - public TerminalNode ORDERING() { return getToken(PostgreSqlParser.ORDERING, 0); } - public TerminalNode ORDINALITY() { return getToken(PostgreSqlParser.ORDINALITY, 0); } - public TerminalNode OTHERS() { return getToken(PostgreSqlParser.OTHERS, 0); } - public TerminalNode OUT() { return getToken(PostgreSqlParser.OUT, 0); } - public TerminalNode OUTPUT() { return getToken(PostgreSqlParser.OUTPUT, 0); } - public TerminalNode OVER() { return getToken(PostgreSqlParser.OVER, 0); } - public TerminalNode OVERLAY() { return getToken(PostgreSqlParser.OVERLAY, 0); } - public TerminalNode OVERRIDING() { return getToken(PostgreSqlParser.OVERRIDING, 0); } - public TerminalNode OWNER() { return getToken(PostgreSqlParser.OWNER, 0); } - public TerminalNode PAD() { return getToken(PostgreSqlParser.PAD, 0); } - public TerminalNode PARAMETER() { return getToken(PostgreSqlParser.PARAMETER, 0); } - public TerminalNode PARAMETER_MODE() { return getToken(PostgreSqlParser.PARAMETER_MODE, 0); } - public TerminalNode PARAMETER_NAME() { return getToken(PostgreSqlParser.PARAMETER_NAME, 0); } - public TerminalNode PARAMETER_ORDINAL_POSITION() { return getToken(PostgreSqlParser.PARAMETER_ORDINAL_POSITION, 0); } - public TerminalNode PARAMETER_SPECIFIC_CATALOG() { return getToken(PostgreSqlParser.PARAMETER_SPECIFIC_CATALOG, 0); } - public TerminalNode PARAMETER_SPECIFIC_NAME() { return getToken(PostgreSqlParser.PARAMETER_SPECIFIC_NAME, 0); } - public TerminalNode PARAMETER_SPECIFIC_SCHEMA() { return getToken(PostgreSqlParser.PARAMETER_SPECIFIC_SCHEMA, 0); } - public TerminalNode PARTIAL() { return getToken(PostgreSqlParser.PARTIAL, 0); } - public TerminalNode PARTITION() { return getToken(PostgreSqlParser.PARTITION, 0); } - public TerminalNode PASCAL() { return getToken(PostgreSqlParser.PASCAL, 0); } - public TerminalNode PASSWORD() { return getToken(PostgreSqlParser.PASSWORD, 0); } - public TerminalNode PATH() { return getToken(PostgreSqlParser.PATH, 0); } - public TerminalNode PERCENTILE_CONT() { return getToken(PostgreSqlParser.PERCENTILE_CONT, 0); } - public TerminalNode PERCENTILE_DISC() { return getToken(PostgreSqlParser.PERCENTILE_DISC, 0); } - public TerminalNode PERCENT_RANK() { return getToken(PostgreSqlParser.PERCENT_RANK, 0); } - public TerminalNode PLAIN() { return getToken(PostgreSqlParser.PLAIN, 0); } - public TerminalNode PLI() { return getToken(PostgreSqlParser.PLI, 0); } - public TerminalNode POSITION() { return getToken(PostgreSqlParser.POSITION, 0); } + public TerminalNode PI() { return getToken(PostgreSqlParser.PI, 0); } public TerminalNode POWER() { return getToken(PostgreSqlParser.POWER, 0); } - public TerminalNode PRECEDING() { return getToken(PostgreSqlParser.PRECEDING, 0); } - public TerminalNode PRECISION() { return getToken(PostgreSqlParser.PRECISION, 0); } - public TerminalNode PREPARE() { return getToken(PostgreSqlParser.PREPARE, 0); } - public TerminalNode PRESERVE() { return getToken(PostgreSqlParser.PRESERVE, 0); } - public TerminalNode PRIOR() { return getToken(PostgreSqlParser.PRIOR, 0); } - public TerminalNode PRIVILEGES() { return getToken(PostgreSqlParser.PRIVILEGES, 0); } - public TerminalNode PROCEDURAL() { return getToken(PostgreSqlParser.PROCEDURAL, 0); } - public TerminalNode PROCEDURE() { return getToken(PostgreSqlParser.PROCEDURE, 0); } - public TerminalNode PUBLIC() { return getToken(PostgreSqlParser.PUBLIC, 0); } - public TerminalNode QUOTE() { return getToken(PostgreSqlParser.QUOTE, 0); } - public TerminalNode RANGE() { return getToken(PostgreSqlParser.RANGE, 0); } - public TerminalNode RANK() { return getToken(PostgreSqlParser.RANK, 0); } - public TerminalNode READ() { return getToken(PostgreSqlParser.READ, 0); } - public TerminalNode READS() { return getToken(PostgreSqlParser.READS, 0); } - public TerminalNode REAL() { return getToken(PostgreSqlParser.REAL, 0); } - public TerminalNode RECHECK() { return getToken(PostgreSqlParser.RECHECK, 0); } - public TerminalNode RECURSIVE() { return getToken(PostgreSqlParser.RECURSIVE, 0); } - public TerminalNode REF() { return getToken(PostgreSqlParser.REF, 0); } - public TerminalNode REFERENCING() { return getToken(PostgreSqlParser.REFERENCING, 0); } - public TerminalNode REFRESH() { return getToken(PostgreSqlParser.REFRESH, 0); } - public TerminalNode REGR_AVGX() { return getToken(PostgreSqlParser.REGR_AVGX, 0); } - public TerminalNode REGR_AVGY() { return getToken(PostgreSqlParser.REGR_AVGY, 0); } - public TerminalNode REGR_COUNT() { return getToken(PostgreSqlParser.REGR_COUNT, 0); } - public TerminalNode REGR_INTERCEPT() { return getToken(PostgreSqlParser.REGR_INTERCEPT, 0); } - public TerminalNode REGR_SLOPE() { return getToken(PostgreSqlParser.REGR_SLOPE, 0); } - public TerminalNode REGR_SXX() { return getToken(PostgreSqlParser.REGR_SXX, 0); } - public TerminalNode REGR_SXY() { return getToken(PostgreSqlParser.REGR_SXY, 0); } - public TerminalNode REGR_SYY() { return getToken(PostgreSqlParser.REGR_SYY, 0); } - public TerminalNode REINDEX() { return getToken(PostgreSqlParser.REINDEX, 0); } - public TerminalNode RELATIVE() { return getToken(PostgreSqlParser.RELATIVE, 0); } - public TerminalNode RELEASE() { return getToken(PostgreSqlParser.RELEASE, 0); } - public TerminalNode RENAME() { return getToken(PostgreSqlParser.RENAME, 0); } - public TerminalNode REPEATABLE() { return getToken(PostgreSqlParser.REPEATABLE, 0); } - public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } - public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } - public TerminalNode RESTART() { return getToken(PostgreSqlParser.RESTART, 0); } - public TerminalNode RESTRICT() { return getToken(PostgreSqlParser.RESTRICT, 0); } - public TerminalNode RESULT() { return getToken(PostgreSqlParser.RESULT, 0); } - public TerminalNode RETURN() { return getToken(PostgreSqlParser.RETURN, 0); } - public TerminalNode RETURNED_CARDINALITY() { return getToken(PostgreSqlParser.RETURNED_CARDINALITY, 0); } - public TerminalNode RETURNED_LENGTH() { return getToken(PostgreSqlParser.RETURNED_LENGTH, 0); } - public TerminalNode RETURNED_OCTET_LENGTH() { return getToken(PostgreSqlParser.RETURNED_OCTET_LENGTH, 0); } - public TerminalNode RETURNED_SQLSTATE() { return getToken(PostgreSqlParser.RETURNED_SQLSTATE, 0); } - public TerminalNode RETURNS() { return getToken(PostgreSqlParser.RETURNS, 0); } - public TerminalNode REVOKE() { return getToken(PostgreSqlParser.REVOKE, 0); } - public TerminalNode RIGHT() { return getToken(PostgreSqlParser.RIGHT, 0); } - public TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 0); } - public TerminalNode ROLLBACK() { return getToken(PostgreSqlParser.ROLLBACK, 0); } - public TerminalNode ROLLUP() { return getToken(PostgreSqlParser.ROLLUP, 0); } - public TerminalNode ROUTINE() { return getToken(PostgreSqlParser.ROUTINE, 0); } - public TerminalNode ROUTINE_CATALOG() { return getToken(PostgreSqlParser.ROUTINE_CATALOG, 0); } - public TerminalNode ROUTINE_NAME() { return getToken(PostgreSqlParser.ROUTINE_NAME, 0); } - public TerminalNode ROUTINE_SCHEMA() { return getToken(PostgreSqlParser.ROUTINE_SCHEMA, 0); } - public TerminalNode ROW() { return getToken(PostgreSqlParser.ROW, 0); } - public TerminalNode ROWS() { return getToken(PostgreSqlParser.ROWS, 0); } - public TerminalNode ROW_COUNT() { return getToken(PostgreSqlParser.ROW_COUNT, 0); } - public TerminalNode ROW_NUMBER() { return getToken(PostgreSqlParser.ROW_NUMBER, 0); } - public TerminalNode RULE() { return getToken(PostgreSqlParser.RULE, 0); } - public TerminalNode SAVEPOINT() { return getToken(PostgreSqlParser.SAVEPOINT, 0); } + public TerminalNode RADIANS() { return getToken(PostgreSqlParser.RADIANS, 0); } + public TerminalNode ROUND() { return getToken(PostgreSqlParser.ROUND, 0); } public TerminalNode SCALE() { return getToken(PostgreSqlParser.SCALE, 0); } - public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } - public TerminalNode SCHEMA_NAME() { return getToken(PostgreSqlParser.SCHEMA_NAME, 0); } - public TerminalNode SCOPE() { return getToken(PostgreSqlParser.SCOPE, 0); } - public TerminalNode SCOPE_CATALOG() { return getToken(PostgreSqlParser.SCOPE_CATALOG, 0); } - public TerminalNode SCOPE_NAME() { return getToken(PostgreSqlParser.SCOPE_NAME, 0); } - public TerminalNode SCOPE_SCHEMA() { return getToken(PostgreSqlParser.SCOPE_SCHEMA, 0); } - public TerminalNode SCROLL() { return getToken(PostgreSqlParser.SCROLL, 0); } - public TerminalNode SEARCH() { return getToken(PostgreSqlParser.SEARCH, 0); } - public TerminalNode SECOND() { return getToken(PostgreSqlParser.SECOND, 0); } - public TerminalNode SECTION() { return getToken(PostgreSqlParser.SECTION, 0); } - public TerminalNode SECURITY() { return getToken(PostgreSqlParser.SECURITY, 0); } - public TerminalNode SELF() { return getToken(PostgreSqlParser.SELF, 0); } - public TerminalNode SENSITIVE() { return getToken(PostgreSqlParser.SENSITIVE, 0); } - public TerminalNode SEQUENCE() { return getToken(PostgreSqlParser.SEQUENCE, 0); } - public TerminalNode SEQUENCES() { return getToken(PostgreSqlParser.SEQUENCES, 0); } - public TerminalNode SERIALIZABLE() { return getToken(PostgreSqlParser.SERIALIZABLE, 0); } - public TerminalNode SERVER_NAME() { return getToken(PostgreSqlParser.SERVER_NAME, 0); } - public TerminalNode SESSION() { return getToken(PostgreSqlParser.SESSION, 0); } - public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } - public TerminalNode SETOF() { return getToken(PostgreSqlParser.SETOF, 0); } - public TerminalNode SETS() { return getToken(PostgreSqlParser.SETS, 0); } - public TerminalNode SHARE() { return getToken(PostgreSqlParser.SHARE, 0); } - public TerminalNode SHOW() { return getToken(PostgreSqlParser.SHOW, 0); } - public TerminalNode SIMPLE() { return getToken(PostgreSqlParser.SIMPLE, 0); } - public TerminalNode SIZE() { return getToken(PostgreSqlParser.SIZE, 0); } - public TerminalNode SMALLINT() { return getToken(PostgreSqlParser.SMALLINT, 0); } - public TerminalNode SOME() { return getToken(PostgreSqlParser.SOME, 0); } - public TerminalNode SOURCE() { return getToken(PostgreSqlParser.SOURCE, 0); } - public TerminalNode SPACE() { return getToken(PostgreSqlParser.SPACE, 0); } - public TerminalNode SPECIFIC() { return getToken(PostgreSqlParser.SPECIFIC, 0); } - public TerminalNode SPECIFICTYPE() { return getToken(PostgreSqlParser.SPECIFICTYPE, 0); } - public TerminalNode SPECIFIC_NAME() { return getToken(PostgreSqlParser.SPECIFIC_NAME, 0); } - public TerminalNode SQL() { return getToken(PostgreSqlParser.SQL, 0); } - public TerminalNode SQLCODE() { return getToken(PostgreSqlParser.SQLCODE, 0); } - public TerminalNode SQLERROR() { return getToken(PostgreSqlParser.SQLERROR, 0); } - public TerminalNode SQLEXCEPTION() { return getToken(PostgreSqlParser.SQLEXCEPTION, 0); } - public TerminalNode SQLSTATE() { return getToken(PostgreSqlParser.SQLSTATE, 0); } - public TerminalNode SQLWARNING() { return getToken(PostgreSqlParser.SQLWARNING, 0); } + public TerminalNode SIGN() { return getToken(PostgreSqlParser.SIGN, 0); } public TerminalNode SQRT() { return getToken(PostgreSqlParser.SQRT, 0); } - public TerminalNode STABLE() { return getToken(PostgreSqlParser.STABLE, 0); } - public TerminalNode START() { return getToken(PostgreSqlParser.START, 0); } - public TerminalNode STATE() { return getToken(PostgreSqlParser.STATE, 0); } - public TerminalNode STATEMENT() { return getToken(PostgreSqlParser.STATEMENT, 0); } - public TerminalNode STATIC() { return getToken(PostgreSqlParser.STATIC, 0); } - public TerminalNode STATISTICS() { return getToken(PostgreSqlParser.STATISTICS, 0); } - public TerminalNode STDDEV_POP() { return getToken(PostgreSqlParser.STDDEV_POP, 0); } - public TerminalNode STDDEV_SAMP() { return getToken(PostgreSqlParser.STDDEV_SAMP, 0); } - public TerminalNode STDIN() { return getToken(PostgreSqlParser.STDIN, 0); } - public TerminalNode STDOUT() { return getToken(PostgreSqlParser.STDOUT, 0); } - public TerminalNode STORAGE() { return getToken(PostgreSqlParser.STORAGE, 0); } - public TerminalNode STRICT() { return getToken(PostgreSqlParser.STRICT, 0); } - public TerminalNode STRUCTURE() { return getToken(PostgreSqlParser.STRUCTURE, 0); } - public TerminalNode STYLE() { return getToken(PostgreSqlParser.STYLE, 0); } - public TerminalNode SUBCLASS_ORIGIN() { return getToken(PostgreSqlParser.SUBCLASS_ORIGIN, 0); } - public TerminalNode SUBMULTISET() { return getToken(PostgreSqlParser.SUBMULTISET, 0); } - public TerminalNode SUBSTRING() { return getToken(PostgreSqlParser.SUBSTRING, 0); } - public TerminalNode SUM() { return getToken(PostgreSqlParser.SUM, 0); } - public TerminalNode SYSID() { return getToken(PostgreSqlParser.SYSID, 0); } - public TerminalNode SYSTEM() { return getToken(PostgreSqlParser.SYSTEM, 0); } - public TerminalNode SYSTEM_USER() { return getToken(PostgreSqlParser.SYSTEM_USER, 0); } - public TerminalNode TABLESPACE() { return getToken(PostgreSqlParser.TABLESPACE, 0); } - public TerminalNode TABLE_NAME() { return getToken(PostgreSqlParser.TABLE_NAME, 0); } - public TerminalNode TEMP() { return getToken(PostgreSqlParser.TEMP, 0); } - public TerminalNode TEMPLATE() { return getToken(PostgreSqlParser.TEMPLATE, 0); } - public TerminalNode TEMPORARY() { return getToken(PostgreSqlParser.TEMPORARY, 0); } - public TerminalNode TEXT() { return getToken(PostgreSqlParser.TEXT, 0); } - public TerminalNode TIES() { return getToken(PostgreSqlParser.TIES, 0); } - public TerminalNode TIME() { return getToken(PostgreSqlParser.TIME, 0); } - public TerminalNode TIMESTAMP() { return getToken(PostgreSqlParser.TIMESTAMP, 0); } - public TerminalNode TIMEZONE_HOUR() { return getToken(PostgreSqlParser.TIMEZONE_HOUR, 0); } - public TerminalNode TIMEZONE_MINUTE() { return getToken(PostgreSqlParser.TIMEZONE_MINUTE, 0); } - public TerminalNode TOP() { return getToken(PostgreSqlParser.TOP, 0); } - public TerminalNode TOP_LEVEL_COUNT() { return getToken(PostgreSqlParser.TOP_LEVEL_COUNT, 0); } - public TerminalNode TRANSACTION() { return getToken(PostgreSqlParser.TRANSACTION, 0); } - public TerminalNode TRANSACTIONS_COMMITTED() { return getToken(PostgreSqlParser.TRANSACTIONS_COMMITTED, 0); } - public TerminalNode TRANSACTIONS_ROLLED_BACK() { return getToken(PostgreSqlParser.TRANSACTIONS_ROLLED_BACK, 0); } - public TerminalNode TRANSACTION_ACTIVE() { return getToken(PostgreSqlParser.TRANSACTION_ACTIVE, 0); } - public TerminalNode TRANSFORM() { return getToken(PostgreSqlParser.TRANSFORM, 0); } - public TerminalNode TRANSFORMS() { return getToken(PostgreSqlParser.TRANSFORMS, 0); } - public TerminalNode TRANSLATE() { return getToken(PostgreSqlParser.TRANSLATE, 0); } - public TerminalNode TRANSLATION() { return getToken(PostgreSqlParser.TRANSLATION, 0); } - public TerminalNode TREAT() { return getToken(PostgreSqlParser.TREAT, 0); } - public TerminalNode TRIGGER() { return getToken(PostgreSqlParser.TRIGGER, 0); } - public TerminalNode TRIGGER_CATALOG() { return getToken(PostgreSqlParser.TRIGGER_CATALOG, 0); } - public TerminalNode TRIGGER_NAME() { return getToken(PostgreSqlParser.TRIGGER_NAME, 0); } - public TerminalNode TRIGGER_SCHEMA() { return getToken(PostgreSqlParser.TRIGGER_SCHEMA, 0); } - public TerminalNode TRIM() { return getToken(PostgreSqlParser.TRIM, 0); } - public TerminalNode TRUE() { return getToken(PostgreSqlParser.TRUE, 0); } - public TerminalNode TRUNCATE() { return getToken(PostgreSqlParser.TRUNCATE, 0); } - public TerminalNode TRUSTED() { return getToken(PostgreSqlParser.TRUSTED, 0); } - public TerminalNode TYPE() { return getToken(PostgreSqlParser.TYPE, 0); } - public TerminalNode UESCAPE() { return getToken(PostgreSqlParser.UESCAPE, 0); } - public TerminalNode UNBOUNDED() { return getToken(PostgreSqlParser.UNBOUNDED, 0); } - public TerminalNode UNCOMMITTED() { return getToken(PostgreSqlParser.UNCOMMITTED, 0); } - public TerminalNode UNDER() { return getToken(PostgreSqlParser.UNDER, 0); } - public TerminalNode UNENCRYPTED() { return getToken(PostgreSqlParser.UNENCRYPTED, 0); } - public TerminalNode UNKNOWN() { return getToken(PostgreSqlParser.UNKNOWN, 0); } - public TerminalNode UNLISTEN() { return getToken(PostgreSqlParser.UNLISTEN, 0); } - public TerminalNode UNNAMED() { return getToken(PostgreSqlParser.UNNAMED, 0); } - public TerminalNode UNNEST() { return getToken(PostgreSqlParser.UNNEST, 0); } - public TerminalNode UNTIL() { return getToken(PostgreSqlParser.UNTIL, 0); } - public TerminalNode UPDATE() { return getToken(PostgreSqlParser.UPDATE, 0); } - public TerminalNode UPPER() { return getToken(PostgreSqlParser.UPPER, 0); } - public TerminalNode USAGE() { return getToken(PostgreSqlParser.USAGE, 0); } - public TerminalNode USER_DEFINED_TYPE_CATALOG() { return getToken(PostgreSqlParser.USER_DEFINED_TYPE_CATALOG, 0); } - public TerminalNode USER_DEFINED_TYPE_CODE() { return getToken(PostgreSqlParser.USER_DEFINED_TYPE_CODE, 0); } - public TerminalNode USER_DEFINED_TYPE_NAME() { return getToken(PostgreSqlParser.USER_DEFINED_TYPE_NAME, 0); } - public TerminalNode USER_DEFINED_TYPE_SCHEMA() { return getToken(PostgreSqlParser.USER_DEFINED_TYPE_SCHEMA, 0); } - public TerminalNode VACUUM() { return getToken(PostgreSqlParser.VACUUM, 0); } - public TerminalNode VALID() { return getToken(PostgreSqlParser.VALID, 0); } - public TerminalNode VALIDATOR() { return getToken(PostgreSqlParser.VALIDATOR, 0); } - public TerminalNode VALUE() { return getToken(PostgreSqlParser.VALUE, 0); } - public TerminalNode VALUES() { return getToken(PostgreSqlParser.VALUES, 0); } - public TerminalNode VARCHAR() { return getToken(PostgreSqlParser.VARCHAR, 0); } - public TerminalNode VARYING() { return getToken(PostgreSqlParser.VARYING, 0); } - public TerminalNode VAR_POP() { return getToken(PostgreSqlParser.VAR_POP, 0); } - public TerminalNode VAR_SAMP() { return getToken(PostgreSqlParser.VAR_SAMP, 0); } - public TerminalNode VERSION() { return getToken(PostgreSqlParser.VERSION, 0); } - public TerminalNode VIEW() { return getToken(PostgreSqlParser.VIEW, 0); } - public TerminalNode VOLATILE() { return getToken(PostgreSqlParser.VOLATILE, 0); } - public TerminalNode WHENEVER() { return getToken(PostgreSqlParser.WHENEVER, 0); } - public TerminalNode WHITESPACE() { return getToken(PostgreSqlParser.WHITESPACE, 0); } + public TerminalNode TRIM_SCALE() { return getToken(PostgreSqlParser.TRIM_SCALE, 0); } + public TerminalNode TRUNC() { return getToken(PostgreSqlParser.TRUNC, 0); } public TerminalNode WIDTH_BUCKET() { return getToken(PostgreSqlParser.WIDTH_BUCKET, 0); } - public TerminalNode WITHIN() { return getToken(PostgreSqlParser.WITHIN, 0); } - public TerminalNode WITHOUT() { return getToken(PostgreSqlParser.WITHOUT, 0); } - public TerminalNode WORK() { return getToken(PostgreSqlParser.WORK, 0); } - public TerminalNode WRITE() { return getToken(PostgreSqlParser.WRITE, 0); } - public TerminalNode YEAR() { return getToken(PostgreSqlParser.YEAR, 0); } - public TerminalNode ZONE() { return getToken(PostgreSqlParser.ZONE, 0); } - public Non_reserved_keywordContext(ParserRuleContext parent, int invokingState) { + public TerminalNode RANDOM() { return getToken(PostgreSqlParser.RANDOM, 0); } + public TerminalNode SETSEED() { return getToken(PostgreSqlParser.SETSEED, 0); } + public TerminalNode ACOS() { return getToken(PostgreSqlParser.ACOS, 0); } + public TerminalNode ACOSD() { return getToken(PostgreSqlParser.ACOSD, 0); } + public TerminalNode ACOSH() { return getToken(PostgreSqlParser.ACOSH, 0); } + public TerminalNode ASIN() { return getToken(PostgreSqlParser.ASIN, 0); } + public TerminalNode ASIND() { return getToken(PostgreSqlParser.ASIND, 0); } + public TerminalNode ASINH() { return getToken(PostgreSqlParser.ASINH, 0); } + public TerminalNode ATAN() { return getToken(PostgreSqlParser.ATAN, 0); } + public TerminalNode ATAND() { return getToken(PostgreSqlParser.ATAND, 0); } + public TerminalNode ATANH() { return getToken(PostgreSqlParser.ATANH, 0); } + public TerminalNode ATAN2() { return getToken(PostgreSqlParser.ATAN2, 0); } + public TerminalNode ATAN2D() { return getToken(PostgreSqlParser.ATAN2D, 0); } + public TerminalNode COS() { return getToken(PostgreSqlParser.COS, 0); } + public TerminalNode COSD() { return getToken(PostgreSqlParser.COSD, 0); } + public TerminalNode COSH() { return getToken(PostgreSqlParser.COSH, 0); } + public TerminalNode COT() { return getToken(PostgreSqlParser.COT, 0); } + public TerminalNode COTD() { return getToken(PostgreSqlParser.COTD, 0); } + public TerminalNode SIN() { return getToken(PostgreSqlParser.SIN, 0); } + public TerminalNode SIND() { return getToken(PostgreSqlParser.SIND, 0); } + public TerminalNode SINH() { return getToken(PostgreSqlParser.SINH, 0); } + public TerminalNode TAN() { return getToken(PostgreSqlParser.TAN, 0); } + public TerminalNode TAND() { return getToken(PostgreSqlParser.TAND, 0); } + public TerminalNode TANH() { return getToken(PostgreSqlParser.TANH, 0); } + public TerminalNode BIT_LENGTH() { return getToken(PostgreSqlParser.BIT_LENGTH, 0); } + public TerminalNode CHAR_LENGTH() { return getToken(PostgreSqlParser.CHAR_LENGTH, 0); } + public TerminalNode CHARACTER_LENGTH() { return getToken(PostgreSqlParser.CHARACTER_LENGTH, 0); } + public TerminalNode LOWER() { return getToken(PostgreSqlParser.LOWER, 0); } + public TerminalNode OCTET_LENGTH() { return getToken(PostgreSqlParser.OCTET_LENGTH, 0); } + public TerminalNode UPPER() { return getToken(PostgreSqlParser.UPPER, 0); } + public TerminalNode ASCII() { return getToken(PostgreSqlParser.ASCII, 0); } + public TerminalNode BTRIM() { return getToken(PostgreSqlParser.BTRIM, 0); } + public TerminalNode CHR() { return getToken(PostgreSqlParser.CHR, 0); } + public TerminalNode CONCAT() { return getToken(PostgreSqlParser.CONCAT, 0); } + public TerminalNode CONCAT_WS() { return getToken(PostgreSqlParser.CONCAT_WS, 0); } + public TerminalNode FORMAT() { return getToken(PostgreSqlParser.FORMAT, 0); } + public TerminalNode INITCAP() { return getToken(PostgreSqlParser.INITCAP, 0); } + public TerminalNode LENGTH() { return getToken(PostgreSqlParser.LENGTH, 0); } + public TerminalNode LPAD() { return getToken(PostgreSqlParser.LPAD, 0); } + public TerminalNode LTRIM() { return getToken(PostgreSqlParser.LTRIM, 0); } + public TerminalNode MD5() { return getToken(PostgreSqlParser.MD5, 0); } + public TerminalNode PARSE_IDENT() { return getToken(PostgreSqlParser.PARSE_IDENT, 0); } + public TerminalNode PG_CLIENT_ENCODING() { return getToken(PostgreSqlParser.PG_CLIENT_ENCODING, 0); } + public TerminalNode QUOTE_IDENT() { return getToken(PostgreSqlParser.QUOTE_IDENT, 0); } + public TerminalNode QUOTE_LITERAL() { return getToken(PostgreSqlParser.QUOTE_LITERAL, 0); } + public TerminalNode QUOTE_NULLABLE() { return getToken(PostgreSqlParser.QUOTE_NULLABLE, 0); } + public TerminalNode REGEXP_COUNT() { return getToken(PostgreSqlParser.REGEXP_COUNT, 0); } + public TerminalNode REGEXP_INSTR() { return getToken(PostgreSqlParser.REGEXP_INSTR, 0); } + public TerminalNode REGEXP_LIKE() { return getToken(PostgreSqlParser.REGEXP_LIKE, 0); } + public TerminalNode REGEXP_MATCH() { return getToken(PostgreSqlParser.REGEXP_MATCH, 0); } + public TerminalNode REGEXP_MATCHES() { return getToken(PostgreSqlParser.REGEXP_MATCHES, 0); } + public TerminalNode REGEXP_REPLACE() { return getToken(PostgreSqlParser.REGEXP_REPLACE, 0); } + public TerminalNode REGEXP_SPLIT_TO_ARRAY() { return getToken(PostgreSqlParser.REGEXP_SPLIT_TO_ARRAY, 0); } + public TerminalNode REGEXP_SPLIT_TO_TABLE() { return getToken(PostgreSqlParser.REGEXP_SPLIT_TO_TABLE, 0); } + public TerminalNode REGEXP_SUBSTR() { return getToken(PostgreSqlParser.REGEXP_SUBSTR, 0); } + public TerminalNode REPEAT() { return getToken(PostgreSqlParser.REPEAT, 0); } + public TerminalNode REPLACE() { return getToken(PostgreSqlParser.REPLACE, 0); } + public TerminalNode REVERSE() { return getToken(PostgreSqlParser.REVERSE, 0); } + public TerminalNode RPAD() { return getToken(PostgreSqlParser.RPAD, 0); } + public TerminalNode RTRIM() { return getToken(PostgreSqlParser.RTRIM, 0); } + public TerminalNode SPLIT_PART() { return getToken(PostgreSqlParser.SPLIT_PART, 0); } + public TerminalNode STARTS_WITH() { return getToken(PostgreSqlParser.STARTS_WITH, 0); } + public TerminalNode STRING_TO_ARRAY() { return getToken(PostgreSqlParser.STRING_TO_ARRAY, 0); } + public TerminalNode STRING_TO_TABLE() { return getToken(PostgreSqlParser.STRING_TO_TABLE, 0); } + public TerminalNode STRPOS() { return getToken(PostgreSqlParser.STRPOS, 0); } + public TerminalNode SUBSTR() { return getToken(PostgreSqlParser.SUBSTR, 0); } + public TerminalNode TO_ASCII() { return getToken(PostgreSqlParser.TO_ASCII, 0); } + public TerminalNode TO_HEX() { return getToken(PostgreSqlParser.TO_HEX, 0); } + public TerminalNode TRANSLATE() { return getToken(PostgreSqlParser.TRANSLATE, 0); } + public TerminalNode UNISTR() { return getToken(PostgreSqlParser.UNISTR, 0); } + public TerminalNode AGE() { return getToken(PostgreSqlParser.AGE, 0); } + public TerminalNode DATE_BIN() { return getToken(PostgreSqlParser.DATE_BIN, 0); } + public TerminalNode DATE_PART() { return getToken(PostgreSqlParser.DATE_PART, 0); } + public TerminalNode DATE_TRUNC() { return getToken(PostgreSqlParser.DATE_TRUNC, 0); } + public TerminalNode ISFINITE() { return getToken(PostgreSqlParser.ISFINITE, 0); } + public TerminalNode JUSTIFY_DAYS() { return getToken(PostgreSqlParser.JUSTIFY_DAYS, 0); } + public TerminalNode JUSTIFY_HOURS() { return getToken(PostgreSqlParser.JUSTIFY_HOURS, 0); } + public TerminalNode JUSTIFY_INTERVAL() { return getToken(PostgreSqlParser.JUSTIFY_INTERVAL, 0); } + public TerminalNode MAKE_DATE() { return getToken(PostgreSqlParser.MAKE_DATE, 0); } + public TerminalNode MAKE_INTERVAL() { return getToken(PostgreSqlParser.MAKE_INTERVAL, 0); } + public TerminalNode MAKE_TIME() { return getToken(PostgreSqlParser.MAKE_TIME, 0); } + public TerminalNode MAKE_TIMESTAMP() { return getToken(PostgreSqlParser.MAKE_TIMESTAMP, 0); } + public TerminalNode MAKE_TIMESTAMPTZ() { return getToken(PostgreSqlParser.MAKE_TIMESTAMPTZ, 0); } + public TerminalNode CLOCK_TIMESTAMP() { return getToken(PostgreSqlParser.CLOCK_TIMESTAMP, 0); } + public TerminalNode NOW() { return getToken(PostgreSqlParser.NOW, 0); } + public TerminalNode STATEMENT_TIMESTAMP() { return getToken(PostgreSqlParser.STATEMENT_TIMESTAMP, 0); } + public TerminalNode TIMEOFDAY() { return getToken(PostgreSqlParser.TIMEOFDAY, 0); } + public TerminalNode TRANSACTION_TIMESTAMP() { return getToken(PostgreSqlParser.TRANSACTION_TIMESTAMP, 0); } + public TerminalNode TO_TIMESTAMP() { return getToken(PostgreSqlParser.TO_TIMESTAMP, 0); } + public TerminalNode TO_CHAR() { return getToken(PostgreSqlParser.TO_CHAR, 0); } + public TerminalNode TO_DATE() { return getToken(PostgreSqlParser.TO_DATE, 0); } + public TerminalNode TO_NUMBER() { return getToken(PostgreSqlParser.TO_NUMBER, 0); } + public Builtin_function_nameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_non_reserved_keyword; } + @Override public int getRuleIndex() { return RULE_builtin_function_name; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNon_reserved_keyword(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterBuiltin_function_name(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNon_reserved_keyword(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitBuiltin_function_name(this); } } - public final Non_reserved_keywordContext non_reserved_keyword() throws RecognitionException { - Non_reserved_keywordContext _localctx = new Non_reserved_keywordContext(_ctx, getState()); - enterRule(_localctx, 526, RULE_non_reserved_keyword); + public final Builtin_function_nameContext builtin_function_name() throws RecognitionException { + Builtin_function_nameContext _localctx = new Builtin_function_nameContext(_ctx, getState()); + enterRule(_localctx, 1394, RULE_builtin_function_name); int _la; try { enterOuterAlt(_localctx, 1); { - setState(5678); + setState(9957); _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 4600110217791700978L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4323417020805627903L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & -346269334810659729L) != 0) || ((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & -164385245456777353L) != 0) || ((((_la - 261)) & ~0x3f) == 0 && ((1L << (_la - 261)) & -4666650814423513617L) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & -3206585526350118915L) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & 8642312967997619065L) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & -72057594172276801L) != 0) || ((((_la - 519)) & ~0x3f) == 0 && ((1L << (_la - 519)) & 8969742741873359583L) != 0) || ((((_la - 585)) & ~0x3f) == 0 && ((1L << (_la - 585)) & 3120954820635131899L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 281474976710831L) != 0) || _la==TEXT) ) { + if ( !(_la==REPLACE || ((((_la - 420)) & ~0x3f) == 0 && ((1L << (_la - 420)) & 127L) != 0) || ((((_la - 506)) & ~0x3f) == 0 && ((1L << (_la - 506)) & -261631L) != 0) || ((((_la - 570)) & ~0x3f) == 0 && ((1L << (_la - 570)) & -1L) != 0) || ((((_la - 634)) & ~0x3f) == 0 && ((1L << (_la - 634)) & 31L) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -48016,148 +88182,5082 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class IdentifierContext extends ParserRuleContext { - public Non_reserved_keywordContext non_reserved_keyword() { - return getRuleContext(Non_reserved_keywordContext.class,0); + public static class Pl_functionContext extends ParserRuleContext { + public Comp_optionsContext comp_options() { + return getRuleContext(Comp_optionsContext.class,0); } - public TerminalNode DOUBLEQ_STRING_LITERAL() { return getToken(PostgreSqlParser.DOUBLEQ_STRING_LITERAL, 0); } - public TerminalNode IDENTIFIER() { return getToken(PostgreSqlParser.IDENTIFIER, 0); } - public Type_nameContext type_name() { - return getRuleContext(Type_nameContext.class,0); + public Pl_blockContext pl_block() { + return getRuleContext(Pl_blockContext.class,0); } - public TerminalNode IDENTIFIER_UNICODE() { return getToken(PostgreSqlParser.IDENTIFIER_UNICODE, 0); } - public List identifier() { - return getRuleContexts(IdentifierContext.class); + public Opt_semiContext opt_semi() { + return getRuleContext(Opt_semiContext.class,0); } - public IdentifierContext identifier(int i) { - return getRuleContext(IdentifierContext.class,i); - } - public TerminalNode DOT() { return getToken(PostgreSqlParser.DOT, 0); } - public IdentifierContext(ParserRuleContext parent, int invokingState) { + public Pl_functionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_identifier; } + @Override public int getRuleIndex() { return RULE_pl_function; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIdentifier(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPl_function(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIdentifier(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPl_function(this); } } - public final IdentifierContext identifier() throws RecognitionException { - return identifier(0); + public final Pl_functionContext pl_function() throws RecognitionException { + Pl_functionContext _localctx = new Pl_functionContext(_ctx, getState()); + enterRule(_localctx, 1396, RULE_pl_function); + try { + enterOuterAlt(_localctx, 1); + { + setState(9959); + comp_options(); + setState(9960); + pl_block(); + setState(9961); + opt_semi(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; } - private IdentifierContext identifier(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - IdentifierContext _localctx = new IdentifierContext(_ctx, _parentState); - IdentifierContext _prevctx = _localctx; - int _startState = 528; - enterRecursionRule(_localctx, 528, RULE_identifier, _p); + @SuppressWarnings("CheckReturnValue") + public static class Comp_optionsContext extends ParserRuleContext { + public List comp_option() { + return getRuleContexts(Comp_optionContext.class); + } + public Comp_optionContext comp_option(int i) { + return getRuleContext(Comp_optionContext.class,i); + } + public Comp_optionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comp_options; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterComp_options(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitComp_options(this); + } + } + + public final Comp_optionsContext comp_options() throws RecognitionException { + Comp_optionsContext _localctx = new Comp_optionsContext(_ctx, getState()); + enterRule(_localctx, 1398, RULE_comp_options); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(9966); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Operator) { + { + { + setState(9963); + comp_option(); + } + } + setState(9968); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Comp_optionContext extends ParserRuleContext { + public SharpContext sharp() { + return getRuleContext(SharpContext.class,0); + } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public TerminalNode DUMP() { return getToken(PostgreSqlParser.DUMP, 0); } + public TerminalNode PRINT_STRICT_PARAMS() { return getToken(PostgreSqlParser.PRINT_STRICT_PARAMS, 0); } + public Option_valueContext option_value() { + return getRuleContext(Option_valueContext.class,0); + } + public TerminalNode VARIABLE_CONFLICT() { return getToken(PostgreSqlParser.VARIABLE_CONFLICT, 0); } + public TerminalNode ERROR() { return getToken(PostgreSqlParser.ERROR, 0); } + public TerminalNode USE_VARIABLE() { return getToken(PostgreSqlParser.USE_VARIABLE, 0); } + public TerminalNode USE_COLUMN() { return getToken(PostgreSqlParser.USE_COLUMN, 0); } + public Comp_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comp_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterComp_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitComp_option(this); + } + } + + public final Comp_optionContext comp_option() throws RecognitionException { + Comp_optionContext _localctx = new Comp_optionContext(_ctx, getState()); + enterRule(_localctx, 1400, RULE_comp_option); + try { + setState(9989); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,667,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9969); + sharp(); + setState(9970); + match(OPTION); + setState(9971); + match(DUMP); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9973); + sharp(); + setState(9974); + match(PRINT_STRICT_PARAMS); + setState(9975); + option_value(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9977); + sharp(); + setState(9978); + match(VARIABLE_CONFLICT); + setState(9979); + match(ERROR); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9981); + sharp(); + setState(9982); + match(VARIABLE_CONFLICT); + setState(9983); + match(USE_VARIABLE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(9985); + sharp(); + setState(9986); + match(VARIABLE_CONFLICT); + setState(9987); + match(USE_COLUMN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SharpContext extends ParserRuleContext { + public TerminalNode Operator() { return getToken(PostgreSqlParser.Operator, 0); } + public SharpContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sharp; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSharp(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSharp(this); + } + } + + public final SharpContext sharp() throws RecognitionException { + SharpContext _localctx = new SharpContext(_ctx, getState()); + enterRule(_localctx, 1402, RULE_sharp); + try { + enterOuterAlt(_localctx, 1); + { + setState(9991); + match(Operator); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Option_valueContext extends ParserRuleContext { + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Reserved_keywordContext reserved_keyword() { + return getRuleContext(Reserved_keywordContext.class,0); + } + public Plsql_unreserved_keywordContext plsql_unreserved_keyword() { + return getRuleContext(Plsql_unreserved_keywordContext.class,0); + } + public Unreserved_keywordContext unreserved_keyword() { + return getRuleContext(Unreserved_keywordContext.class,0); + } + public Option_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_option_value; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOption_value(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOption_value(this); + } + } + + public final Option_valueContext option_value() throws RecognitionException { + Option_valueContext _localctx = new Option_valueContext(_ctx, getState()); + enterRule(_localctx, 1404, RULE_option_value); + try { + setState(9997); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,668,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(9993); + sconst(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(9994); + reserved_keyword(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(9995); + plsql_unreserved_keyword(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(9996); + unreserved_keyword(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_semiContext extends ParserRuleContext { + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Opt_semiContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_semi; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_semi(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_semi(this); + } + } + + public final Opt_semiContext opt_semi() throws RecognitionException { + Opt_semiContext _localctx = new Opt_semiContext(_ctx, getState()); + enterRule(_localctx, 1406, RULE_opt_semi); + try { + setState(10001); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EOF: + enterOuterAlt(_localctx, 1); + { + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(10000); + match(SEMI); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Pl_blockContext extends ParserRuleContext { + public Decl_sectContext decl_sect() { + return getRuleContext(Decl_sectContext.class,0); + } + public TerminalNode BEGIN_P() { return getToken(PostgreSqlParser.BEGIN_P, 0); } + public Proc_sectContext proc_sect() { + return getRuleContext(Proc_sectContext.class,0); + } + public Exception_sectContext exception_sect() { + return getRuleContext(Exception_sectContext.class,0); + } + public TerminalNode END_P() { return getToken(PostgreSqlParser.END_P, 0); } + public Opt_labelContext opt_label() { + return getRuleContext(Opt_labelContext.class,0); + } + public Pl_blockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pl_block; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPl_block(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPl_block(this); + } + } + + public final Pl_blockContext pl_block() throws RecognitionException { + Pl_blockContext _localctx = new Pl_blockContext(_ctx, getState()); + enterRule(_localctx, 1408, RULE_pl_block); + try { + enterOuterAlt(_localctx, 1); + { + setState(10003); + decl_sect(); + setState(10004); + match(BEGIN_P); + setState(10005); + proc_sect(); + setState(10006); + exception_sect(); + setState(10007); + match(END_P); + setState(10008); + opt_label(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_sectContext extends ParserRuleContext { + public Opt_block_labelContext opt_block_label() { + return getRuleContext(Opt_block_labelContext.class,0); + } + public Decl_startContext decl_start() { + return getRuleContext(Decl_startContext.class,0); + } + public Decl_stmtsContext decl_stmts() { + return getRuleContext(Decl_stmtsContext.class,0); + } + public Decl_sectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_sect; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_sect(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_sect(this); + } + } + + public final Decl_sectContext decl_sect() throws RecognitionException { + Decl_sectContext _localctx = new Decl_sectContext(_ctx, getState()); + enterRule(_localctx, 1410, RULE_decl_sect); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10010); + opt_block_label(); + setState(10015); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DECLARE) { + { + setState(10011); + decl_start(); + setState(10013); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,670,_ctx) ) { + case 1: + { + setState(10012); + decl_stmts(); + } + break; + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_startContext extends ParserRuleContext { + public TerminalNode DECLARE() { return getToken(PostgreSqlParser.DECLARE, 0); } + public Decl_startContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_start; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_start(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_start(this); + } + } + + public final Decl_startContext decl_start() throws RecognitionException { + Decl_startContext _localctx = new Decl_startContext(_ctx, getState()); + enterRule(_localctx, 1412, RULE_decl_start); + try { + enterOuterAlt(_localctx, 1); + { + setState(10017); + match(DECLARE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_stmtsContext extends ParserRuleContext { + public List decl_stmt() { + return getRuleContexts(Decl_stmtContext.class); + } + public Decl_stmtContext decl_stmt(int i) { + return getRuleContext(Decl_stmtContext.class,i); + } + public Decl_stmtsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_stmts; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_stmts(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_stmts(this); + } + } + + public final Decl_stmtsContext decl_stmts() throws RecognitionException { + Decl_stmtsContext _localctx = new Decl_stmtsContext(_ctx, getState()); + enterRule(_localctx, 1414, RULE_decl_stmts); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(5686); + setState(10020); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,700,_ctx) ) { + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(10019); + decl_stmt(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(10022); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,672,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Label_declContext extends ParserRuleContext { + public TerminalNode LESS_LESS() { return getToken(PostgreSqlParser.LESS_LESS, 0); } + public Any_identifierContext any_identifier() { + return getRuleContext(Any_identifierContext.class,0); + } + public TerminalNode GREATER_GREATER() { return getToken(PostgreSqlParser.GREATER_GREATER, 0); } + public Label_declContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_label_decl; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLabel_decl(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLabel_decl(this); + } + } + + public final Label_declContext label_decl() throws RecognitionException { + Label_declContext _localctx = new Label_declContext(_ctx, getState()); + enterRule(_localctx, 1416, RULE_label_decl); + try { + enterOuterAlt(_localctx, 1); + { + setState(10024); + match(LESS_LESS); + setState(10025); + any_identifier(); + setState(10026); + match(GREATER_GREATER); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_stmtContext extends ParserRuleContext { + public Decl_statementContext decl_statement() { + return getRuleContext(Decl_statementContext.class,0); + } + public TerminalNode DECLARE() { return getToken(PostgreSqlParser.DECLARE, 0); } + public Label_declContext label_decl() { + return getRuleContext(Label_declContext.class,0); + } + public Decl_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_stmt(this); + } + } + + public final Decl_stmtContext decl_stmt() throws RecognitionException { + Decl_stmtContext _localctx = new Decl_stmtContext(_ctx, getState()); + enterRule(_localctx, 1418, RULE_decl_stmt); + try { + setState(10031); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,673,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(10028); + decl_statement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10029); + match(DECLARE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(10030); + label_decl(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_statementContext extends ParserRuleContext { + public Decl_varnameContext decl_varname() { + return getRuleContext(Decl_varnameContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public TerminalNode ALIAS() { return getToken(PostgreSqlParser.ALIAS, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Decl_aliasitemContext decl_aliasitem() { + return getRuleContext(Decl_aliasitemContext.class,0); + } + public Decl_constContext decl_const() { + return getRuleContext(Decl_constContext.class,0); + } + public Decl_datatypeContext decl_datatype() { + return getRuleContext(Decl_datatypeContext.class,0); + } + public Decl_collateContext decl_collate() { + return getRuleContext(Decl_collateContext.class,0); + } + public Decl_notnullContext decl_notnull() { + return getRuleContext(Decl_notnullContext.class,0); + } + public Decl_defvalContext decl_defval() { + return getRuleContext(Decl_defvalContext.class,0); + } + public Opt_scrollableContext opt_scrollable() { + return getRuleContext(Opt_scrollableContext.class,0); + } + public TerminalNode CURSOR() { return getToken(PostgreSqlParser.CURSOR, 0); } + public Decl_cursor_argsContext decl_cursor_args() { + return getRuleContext(Decl_cursor_argsContext.class,0); + } + public Decl_is_forContext decl_is_for() { + return getRuleContext(Decl_is_forContext.class,0); + } + public Decl_cursor_queryContext decl_cursor_query() { + return getRuleContext(Decl_cursor_queryContext.class,0); + } + public Decl_statementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_statement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_statement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_statement(this); + } + } + + public final Decl_statementContext decl_statement() throws RecognitionException { + Decl_statementContext _localctx = new Decl_statementContext(_ctx, getState()); + enterRule(_localctx, 1420, RULE_decl_statement); + try { + enterOuterAlt(_localctx, 1); + { + setState(10033); + decl_varname(); + setState(10049); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,674,_ctx) ) { case 1: { - setState(5681); - non_reserved_keyword(); + setState(10034); + match(ALIAS); + setState(10035); + match(FOR); + setState(10036); + decl_aliasitem(); } break; case 2: { - setState(5682); - match(DOUBLEQ_STRING_LITERAL); + setState(10037); + decl_const(); + setState(10038); + decl_datatype(); + setState(10039); + decl_collate(); + setState(10040); + decl_notnull(); + setState(10041); + decl_defval(); } break; case 3: { - setState(5683); - match(IDENTIFIER); + setState(10043); + opt_scrollable(); + setState(10044); + match(CURSOR); + setState(10045); + decl_cursor_args(); + setState(10046); + decl_is_for(); + setState(10047); + decl_cursor_query(); + } + break; + } + setState(10051); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_scrollableContext extends ParserRuleContext { + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode SCROLL() { return getToken(PostgreSqlParser.SCROLL, 0); } + public Opt_scrollableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_scrollable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_scrollable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_scrollable(this); + } + } + + public final Opt_scrollableContext opt_scrollable() throws RecognitionException { + Opt_scrollableContext _localctx = new Opt_scrollableContext(_ctx, getState()); + enterRule(_localctx, 1422, RULE_opt_scrollable); + try { + setState(10057); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CURSOR: + enterOuterAlt(_localctx, 1); + { + } + break; + case NO: + enterOuterAlt(_localctx, 2); + { + setState(10054); + match(NO); + setState(10055); + match(SCROLL); + } + break; + case SCROLL: + enterOuterAlt(_localctx, 3); + { + setState(10056); + match(SCROLL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_cursor_queryContext extends ParserRuleContext { + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public Decl_cursor_queryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_cursor_query; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_cursor_query(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_cursor_query(this); + } + } + + public final Decl_cursor_queryContext decl_cursor_query() throws RecognitionException { + Decl_cursor_queryContext _localctx = new Decl_cursor_queryContext(_ctx, getState()); + enterRule(_localctx, 1424, RULE_decl_cursor_query); + try { + enterOuterAlt(_localctx, 1); + { + setState(10059); + selectstmt(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_cursor_argsContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Decl_cursor_arglistContext decl_cursor_arglist() { + return getRuleContext(Decl_cursor_arglistContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Decl_cursor_argsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_cursor_args; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_cursor_args(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_cursor_args(this); + } + } + + public final Decl_cursor_argsContext decl_cursor_args() throws RecognitionException { + Decl_cursor_argsContext _localctx = new Decl_cursor_argsContext(_ctx, getState()); + enterRule(_localctx, 1426, RULE_decl_cursor_args); + try { + setState(10066); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + case IS: + enterOuterAlt(_localctx, 1); + { + } + break; + case OPEN_PAREN: + enterOuterAlt(_localctx, 2); + { + setState(10062); + match(OPEN_PAREN); + setState(10063); + decl_cursor_arglist(); + setState(10064); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_cursor_arglistContext extends ParserRuleContext { + public List decl_cursor_arg() { + return getRuleContexts(Decl_cursor_argContext.class); + } + public Decl_cursor_argContext decl_cursor_arg(int i) { + return getRuleContext(Decl_cursor_argContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Decl_cursor_arglistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_cursor_arglist; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_cursor_arglist(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_cursor_arglist(this); + } + } + + public final Decl_cursor_arglistContext decl_cursor_arglist() throws RecognitionException { + Decl_cursor_arglistContext _localctx = new Decl_cursor_arglistContext(_ctx, getState()); + enterRule(_localctx, 1428, RULE_decl_cursor_arglist); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10068); + decl_cursor_arg(); + setState(10073); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(10069); + match(COMMA); + setState(10070); + decl_cursor_arg(); + } + } + setState(10075); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_cursor_argContext extends ParserRuleContext { + public Decl_varnameContext decl_varname() { + return getRuleContext(Decl_varnameContext.class,0); + } + public Decl_datatypeContext decl_datatype() { + return getRuleContext(Decl_datatypeContext.class,0); + } + public Decl_cursor_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_cursor_arg; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_cursor_arg(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_cursor_arg(this); + } + } + + public final Decl_cursor_argContext decl_cursor_arg() throws RecognitionException { + Decl_cursor_argContext _localctx = new Decl_cursor_argContext(_ctx, getState()); + enterRule(_localctx, 1430, RULE_decl_cursor_arg); + try { + enterOuterAlt(_localctx, 1); + { + setState(10076); + decl_varname(); + setState(10077); + decl_datatype(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_is_forContext extends ParserRuleContext { + public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public Decl_is_forContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_is_for; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_is_for(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_is_for(this); + } + } + + public final Decl_is_forContext decl_is_for() throws RecognitionException { + Decl_is_forContext _localctx = new Decl_is_forContext(_ctx, getState()); + enterRule(_localctx, 1432, RULE_decl_is_for); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10079); + _la = _input.LA(1); + if ( !(_la==FOR || _la==IS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_aliasitemContext extends ParserRuleContext { + public TerminalNode PARAM() { return getToken(PostgreSqlParser.PARAM, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Decl_aliasitemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_aliasitem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_aliasitem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_aliasitem(this); + } + } + + public final Decl_aliasitemContext decl_aliasitem() throws RecognitionException { + Decl_aliasitemContext _localctx = new Decl_aliasitemContext(_ctx, getState()); + enterRule(_localctx, 1434, RULE_decl_aliasitem); + try { + setState(10083); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PARAM: + enterOuterAlt(_localctx, 1); + { + setState(10081); + match(PARAM); + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(10082); + colid(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_varnameContext extends ParserRuleContext { + public Any_identifierContext any_identifier() { + return getRuleContext(Any_identifierContext.class,0); + } + public Decl_varnameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_varname; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_varname(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_varname(this); + } + } + + public final Decl_varnameContext decl_varname() throws RecognitionException { + Decl_varnameContext _localctx = new Decl_varnameContext(_ctx, getState()); + enterRule(_localctx, 1436, RULE_decl_varname); + try { + enterOuterAlt(_localctx, 1); + { + setState(10085); + any_identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_constContext extends ParserRuleContext { + public TerminalNode CONSTANT() { return getToken(PostgreSqlParser.CONSTANT, 0); } + public Decl_constContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_const; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_const(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_const(this); + } + } + + public final Decl_constContext decl_const() throws RecognitionException { + Decl_constContext _localctx = new Decl_constContext(_ctx, getState()); + enterRule(_localctx, 1438, RULE_decl_const); + try { + setState(10089); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,679,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10088); + match(CONSTANT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_datatypeContext extends ParserRuleContext { + public TypenameContext typename() { + return getRuleContext(TypenameContext.class,0); + } + public Decl_datatypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_datatype; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_datatype(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_datatype(this); + } + } + + public final Decl_datatypeContext decl_datatype() throws RecognitionException { + Decl_datatypeContext _localctx = new Decl_datatypeContext(_ctx, getState()); + enterRule(_localctx, 1440, RULE_decl_datatype); + try { + enterOuterAlt(_localctx, 1); + { + setState(10091); + typename(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_collateContext extends ParserRuleContext { + public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public Decl_collateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_collate; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_collate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_collate(this); + } + } + + public final Decl_collateContext decl_collate() throws RecognitionException { + Decl_collateContext _localctx = new Decl_collateContext(_ctx, getState()); + enterRule(_localctx, 1442, RULE_decl_collate); + try { + setState(10096); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + case EQUAL: + case COLON_EQUALS: + case DEFAULT: + case NOT: + enterOuterAlt(_localctx, 1); + { + } + break; + case COLLATE: + enterOuterAlt(_localctx, 2); + { + setState(10094); + match(COLLATE); + setState(10095); + any_name(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_notnullContext extends ParserRuleContext { + public TerminalNode NOT() { return getToken(PostgreSqlParser.NOT, 0); } + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public Decl_notnullContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_notnull; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_notnull(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_notnull(this); + } + } + + public final Decl_notnullContext decl_notnull() throws RecognitionException { + Decl_notnullContext _localctx = new Decl_notnullContext(_ctx, getState()); + enterRule(_localctx, 1444, RULE_decl_notnull); + try { + setState(10101); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + case EQUAL: + case COLON_EQUALS: + case DEFAULT: + enterOuterAlt(_localctx, 1); + { + } + break; + case NOT: + enterOuterAlt(_localctx, 2); + { + setState(10099); + match(NOT); + setState(10100); + match(NULL_P); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_defvalContext extends ParserRuleContext { + public Decl_defkeyContext decl_defkey() { + return getRuleContext(Decl_defkeyContext.class,0); + } + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public Decl_defvalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_defval; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_defval(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_defval(this); + } + } + + public final Decl_defvalContext decl_defval() throws RecognitionException { + Decl_defvalContext _localctx = new Decl_defvalContext(_ctx, getState()); + enterRule(_localctx, 1446, RULE_decl_defval); + try { + setState(10107); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + enterOuterAlt(_localctx, 1); + { + } + break; + case EQUAL: + case COLON_EQUALS: + case DEFAULT: + enterOuterAlt(_localctx, 2); + { + setState(10104); + decl_defkey(); + setState(10105); + sql_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Decl_defkeyContext extends ParserRuleContext { + public Assign_operatorContext assign_operator() { + return getRuleContext(Assign_operatorContext.class,0); + } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public Decl_defkeyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decl_defkey; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDecl_defkey(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDecl_defkey(this); + } + } + + public final Decl_defkeyContext decl_defkey() throws RecognitionException { + Decl_defkeyContext _localctx = new Decl_defkeyContext(_ctx, getState()); + enterRule(_localctx, 1448, RULE_decl_defkey); + try { + setState(10111); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EQUAL: + case COLON_EQUALS: + enterOuterAlt(_localctx, 1); + { + setState(10109); + assign_operator(); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 2); + { + setState(10110); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Assign_operatorContext extends ParserRuleContext { + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public TerminalNode COLON_EQUALS() { return getToken(PostgreSqlParser.COLON_EQUALS, 0); } + public Assign_operatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assign_operator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAssign_operator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAssign_operator(this); + } + } + + public final Assign_operatorContext assign_operator() throws RecognitionException { + Assign_operatorContext _localctx = new Assign_operatorContext(_ctx, getState()); + enterRule(_localctx, 1450, RULE_assign_operator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10113); + _la = _input.LA(1); + if ( !(_la==EQUAL || _la==COLON_EQUALS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Proc_sectContext extends ParserRuleContext { + public List proc_stmt() { + return getRuleContexts(Proc_stmtContext.class); + } + public Proc_stmtContext proc_stmt(int i) { + return getRuleContext(Proc_stmtContext.class,i); + } + public Proc_sectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_proc_sect; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterProc_sect(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitProc_sect(this); + } + } + + public final Proc_sectContext proc_sect() throws RecognitionException { + Proc_sectContext _localctx = new Proc_sectContext(_ctx, getState()); + enterRule(_localctx, 1452, RULE_proc_sect); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(10118); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,684,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(10115); + proc_stmt(); + } + } + } + setState(10120); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,684,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Proc_stmtContext extends ParserRuleContext { + public Pl_blockContext pl_block() { + return getRuleContext(Pl_blockContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_returnContext stmt_return() { + return getRuleContext(Stmt_returnContext.class,0); + } + public Stmt_raiseContext stmt_raise() { + return getRuleContext(Stmt_raiseContext.class,0); + } + public Stmt_assignContext stmt_assign() { + return getRuleContext(Stmt_assignContext.class,0); + } + public Stmt_ifContext stmt_if() { + return getRuleContext(Stmt_ifContext.class,0); + } + public Stmt_caseContext stmt_case() { + return getRuleContext(Stmt_caseContext.class,0); + } + public Stmt_loopContext stmt_loop() { + return getRuleContext(Stmt_loopContext.class,0); + } + public Stmt_whileContext stmt_while() { + return getRuleContext(Stmt_whileContext.class,0); + } + public Stmt_forContext stmt_for() { + return getRuleContext(Stmt_forContext.class,0); + } + public Stmt_foreach_aContext stmt_foreach_a() { + return getRuleContext(Stmt_foreach_aContext.class,0); + } + public Stmt_exitContext stmt_exit() { + return getRuleContext(Stmt_exitContext.class,0); + } + public Stmt_assertContext stmt_assert() { + return getRuleContext(Stmt_assertContext.class,0); + } + public Stmt_execsqlContext stmt_execsql() { + return getRuleContext(Stmt_execsqlContext.class,0); + } + public Stmt_dynexecuteContext stmt_dynexecute() { + return getRuleContext(Stmt_dynexecuteContext.class,0); + } + public Stmt_performContext stmt_perform() { + return getRuleContext(Stmt_performContext.class,0); + } + public Stmt_callContext stmt_call() { + return getRuleContext(Stmt_callContext.class,0); + } + public Stmt_getdiagContext stmt_getdiag() { + return getRuleContext(Stmt_getdiagContext.class,0); + } + public Stmt_openContext stmt_open() { + return getRuleContext(Stmt_openContext.class,0); + } + public Stmt_fetchContext stmt_fetch() { + return getRuleContext(Stmt_fetchContext.class,0); + } + public Stmt_moveContext stmt_move() { + return getRuleContext(Stmt_moveContext.class,0); + } + public Stmt_closeContext stmt_close() { + return getRuleContext(Stmt_closeContext.class,0); + } + public Stmt_nullContext stmt_null() { + return getRuleContext(Stmt_nullContext.class,0); + } + public Stmt_commitContext stmt_commit() { + return getRuleContext(Stmt_commitContext.class,0); + } + public Stmt_rollbackContext stmt_rollback() { + return getRuleContext(Stmt_rollbackContext.class,0); + } + public Stmt_setContext stmt_set() { + return getRuleContext(Stmt_setContext.class,0); + } + public Proc_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_proc_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterProc_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitProc_stmt(this); + } + } + + public final Proc_stmtContext proc_stmt() throws RecognitionException { + Proc_stmtContext _localctx = new Proc_stmtContext(_ctx, getState()); + enterRule(_localctx, 1454, RULE_proc_stmt); + try { + setState(10148); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,685,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(10121); + pl_block(); + setState(10122); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10124); + stmt_return(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(10125); + stmt_raise(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(10126); + stmt_assign(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(10127); + stmt_if(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(10128); + stmt_case(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(10129); + stmt_loop(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(10130); + stmt_while(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(10131); + stmt_for(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(10132); + stmt_foreach_a(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(10133); + stmt_exit(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(10134); + stmt_assert(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(10135); + stmt_execsql(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(10136); + stmt_dynexecute(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(10137); + stmt_perform(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(10138); + stmt_call(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(10139); + stmt_getdiag(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(10140); + stmt_open(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(10141); + stmt_fetch(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(10142); + stmt_move(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(10143); + stmt_close(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(10144); + stmt_null(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(10145); + stmt_commit(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(10146); + stmt_rollback(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(10147); + stmt_set(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_performContext extends ParserRuleContext { + public TerminalNode PERFORM() { return getToken(PostgreSqlParser.PERFORM, 0); } + public Expr_until_semiContext expr_until_semi() { + return getRuleContext(Expr_until_semiContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_performContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_perform; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_perform(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_perform(this); + } + } + + public final Stmt_performContext stmt_perform() throws RecognitionException { + Stmt_performContext _localctx = new Stmt_performContext(_ctx, getState()); + enterRule(_localctx, 1456, RULE_stmt_perform); + try { + enterOuterAlt(_localctx, 1); + { + setState(10150); + match(PERFORM); + setState(10151); + expr_until_semi(); + setState(10152); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_callContext extends ParserRuleContext { + public TerminalNode CALL() { return getToken(PostgreSqlParser.CALL, 0); } + public Any_identifierContext any_identifier() { + return getRuleContext(Any_identifierContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Opt_expr_listContext opt_expr_list() { + return getRuleContext(Opt_expr_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public TerminalNode DO() { return getToken(PostgreSqlParser.DO, 0); } + public Stmt_callContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_call; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_call(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_call(this); + } + } + + public final Stmt_callContext stmt_call() throws RecognitionException { + Stmt_callContext _localctx = new Stmt_callContext(_ctx, getState()); + enterRule(_localctx, 1458, RULE_stmt_call); + try { + setState(10168); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CALL: + enterOuterAlt(_localctx, 1); + { + setState(10154); + match(CALL); + setState(10155); + any_identifier(); + setState(10156); + match(OPEN_PAREN); + setState(10157); + opt_expr_list(); + setState(10158); + match(CLOSE_PAREN); + setState(10159); + match(SEMI); + } + break; + case DO: + enterOuterAlt(_localctx, 2); + { + setState(10161); + match(DO); + setState(10162); + any_identifier(); + setState(10163); + match(OPEN_PAREN); + setState(10164); + opt_expr_list(); + setState(10165); + match(CLOSE_PAREN); + setState(10166); + match(SEMI); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_expr_listContext extends ParserRuleContext { + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Opt_expr_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_expr_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_expr_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_expr_list(this); + } + } + + public final Opt_expr_listContext opt_expr_list() throws RecognitionException { + Opt_expr_listContext _localctx = new Opt_expr_listContext(_ctx, getState()); + enterRule(_localctx, 1460, RULE_opt_expr_list); + try { + setState(10172); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLOSE_PAREN: + enterOuterAlt(_localctx, 1); + { + } + break; + case OPEN_PAREN: + case COLON: + case QUESTION: + case PLUS: + case MINUS: + case PARAM: + case Operator: + case AND: + case ARRAY: + case CASE: + case CAST: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case CURRENT_CATALOG: + case CURRENT_DATE: + case CURRENT_ROLE: + case CURRENT_TIME: + case CURRENT_TIMESTAMP: + case CURRENT_USER: + case DEFAULT: + case DO: + case FALSE_P: + case FETCH: + case LOCALTIME: + case LOCALTIMESTAMP: + case NOT: + case NULL_P: + case SESSION_USER: + case TABLE: + case TRUE_P: + case UNIQUE: + case USER: + case AUTHORIZATION: + case BINARY: + case COLLATION: + case CONCURRENTLY: + case CROSS: + case CURRENT_SCHEMA: + case FREEZE: + case FULL: + case ILIKE: + case INNER_P: + case IS: + case ISNULL: + case JOIN: + case LEFT: + case LIKE: + case NATURAL: + case NOTNULL: + case OUTER_P: + case OVER: + case OVERLAPS: + case RIGHT: + case SIMILAR: + case VERBOSE: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case TABLESAMPLE: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case StringConstant: + case UnicodeEscapeStringConstant: + case BeginDollarStringConstant: + case BinaryStringConstant: + case HexadecimalStringConstant: + case Integral: + case Numeric: + case PLSQLIDENTIFIER: + case EscapeStringConstant: + enterOuterAlt(_localctx, 2); + { + setState(10171); + expr_list(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_assignContext extends ParserRuleContext { + public Assign_varContext assign_var() { + return getRuleContext(Assign_varContext.class,0); + } + public Assign_operatorContext assign_operator() { + return getRuleContext(Assign_operatorContext.class,0); + } + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_assignContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_assign; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_assign(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_assign(this); + } + } + + public final Stmt_assignContext stmt_assign() throws RecognitionException { + Stmt_assignContext _localctx = new Stmt_assignContext(_ctx, getState()); + enterRule(_localctx, 1462, RULE_stmt_assign); + try { + enterOuterAlt(_localctx, 1); + { + setState(10174); + assign_var(); + setState(10175); + assign_operator(); + setState(10176); + sql_expression(); + setState(10177); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_getdiagContext extends ParserRuleContext { + public TerminalNode GET() { return getToken(PostgreSqlParser.GET, 0); } + public Getdiag_area_optContext getdiag_area_opt() { + return getRuleContext(Getdiag_area_optContext.class,0); + } + public TerminalNode DIAGNOSTICS() { return getToken(PostgreSqlParser.DIAGNOSTICS, 0); } + public Getdiag_listContext getdiag_list() { + return getRuleContext(Getdiag_listContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_getdiagContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_getdiag; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_getdiag(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_getdiag(this); + } + } + + public final Stmt_getdiagContext stmt_getdiag() throws RecognitionException { + Stmt_getdiagContext _localctx = new Stmt_getdiagContext(_ctx, getState()); + enterRule(_localctx, 1464, RULE_stmt_getdiag); + try { + enterOuterAlt(_localctx, 1); + { + setState(10179); + match(GET); + setState(10180); + getdiag_area_opt(); + setState(10181); + match(DIAGNOSTICS); + setState(10182); + getdiag_list(); + setState(10183); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Getdiag_area_optContext extends ParserRuleContext { + public TerminalNode CURRENT_P() { return getToken(PostgreSqlParser.CURRENT_P, 0); } + public TerminalNode STACKED() { return getToken(PostgreSqlParser.STACKED, 0); } + public Getdiag_area_optContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_getdiag_area_opt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGetdiag_area_opt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGetdiag_area_opt(this); + } + } + + public final Getdiag_area_optContext getdiag_area_opt() throws RecognitionException { + Getdiag_area_optContext _localctx = new Getdiag_area_optContext(_ctx, getState()); + enterRule(_localctx, 1466, RULE_getdiag_area_opt); + try { + setState(10188); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DIAGNOSTICS: + enterOuterAlt(_localctx, 1); + { + } + break; + case CURRENT_P: + enterOuterAlt(_localctx, 2); + { + setState(10186); + match(CURRENT_P); + } + break; + case STACKED: + enterOuterAlt(_localctx, 3); + { + setState(10187); + match(STACKED); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Getdiag_listContext extends ParserRuleContext { + public List getdiag_list_item() { + return getRuleContexts(Getdiag_list_itemContext.class); + } + public Getdiag_list_itemContext getdiag_list_item(int i) { + return getRuleContext(Getdiag_list_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Getdiag_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_getdiag_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGetdiag_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGetdiag_list(this); + } + } + + public final Getdiag_listContext getdiag_list() throws RecognitionException { + Getdiag_listContext _localctx = new Getdiag_listContext(_ctx, getState()); + enterRule(_localctx, 1468, RULE_getdiag_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10190); + getdiag_list_item(); + setState(10195); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(10191); + match(COMMA); + setState(10192); + getdiag_list_item(); + } + } + setState(10197); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Getdiag_list_itemContext extends ParserRuleContext { + public Getdiag_targetContext getdiag_target() { + return getRuleContext(Getdiag_targetContext.class,0); + } + public Assign_operatorContext assign_operator() { + return getRuleContext(Assign_operatorContext.class,0); + } + public Getdiag_itemContext getdiag_item() { + return getRuleContext(Getdiag_itemContext.class,0); + } + public Getdiag_list_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_getdiag_list_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGetdiag_list_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGetdiag_list_item(this); + } + } + + public final Getdiag_list_itemContext getdiag_list_item() throws RecognitionException { + Getdiag_list_itemContext _localctx = new Getdiag_list_itemContext(_ctx, getState()); + enterRule(_localctx, 1470, RULE_getdiag_list_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(10198); + getdiag_target(); + setState(10199); + assign_operator(); + setState(10200); + getdiag_item(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Getdiag_itemContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Getdiag_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_getdiag_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGetdiag_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGetdiag_item(this); + } + } + + public final Getdiag_itemContext getdiag_item() throws RecognitionException { + Getdiag_itemContext _localctx = new Getdiag_itemContext(_ctx, getState()); + enterRule(_localctx, 1472, RULE_getdiag_item); + try { + enterOuterAlt(_localctx, 1); + { + setState(10202); + colid(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Getdiag_targetContext extends ParserRuleContext { + public Assign_varContext assign_var() { + return getRuleContext(Assign_varContext.class,0); + } + public Getdiag_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_getdiag_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGetdiag_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGetdiag_target(this); + } + } + + public final Getdiag_targetContext getdiag_target() throws RecognitionException { + Getdiag_targetContext _localctx = new Getdiag_targetContext(_ctx, getState()); + enterRule(_localctx, 1474, RULE_getdiag_target); + try { + enterOuterAlt(_localctx, 1); + { + setState(10204); + assign_var(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Assign_varContext extends ParserRuleContext { + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode PARAM() { return getToken(PostgreSqlParser.PARAM, 0); } + public List OPEN_BRACKET() { return getTokens(PostgreSqlParser.OPEN_BRACKET); } + public TerminalNode OPEN_BRACKET(int i) { + return getToken(PostgreSqlParser.OPEN_BRACKET, i); + } + public List expr_until_rightbracket() { + return getRuleContexts(Expr_until_rightbracketContext.class); + } + public Expr_until_rightbracketContext expr_until_rightbracket(int i) { + return getRuleContext(Expr_until_rightbracketContext.class,i); + } + public List CLOSE_BRACKET() { return getTokens(PostgreSqlParser.CLOSE_BRACKET); } + public TerminalNode CLOSE_BRACKET(int i) { + return getToken(PostgreSqlParser.CLOSE_BRACKET, i); + } + public Assign_varContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assign_var; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAssign_var(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAssign_var(this); + } + } + + public final Assign_varContext assign_var() throws RecognitionException { + Assign_varContext _localctx = new Assign_varContext(_ctx, getState()); + enterRule(_localctx, 1476, RULE_assign_var); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10208); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(10206); + any_name(); + } + break; + case PARAM: + { + setState(10207); + match(PARAM); + } + break; + default: + throw new NoViableAltException(this); + } + setState(10216); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OPEN_BRACKET) { + { + { + setState(10210); + match(OPEN_BRACKET); + setState(10211); + expr_until_rightbracket(); + setState(10212); + match(CLOSE_BRACKET); + } + } + setState(10218); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_ifContext extends ParserRuleContext { + public List IF_P() { return getTokens(PostgreSqlParser.IF_P); } + public TerminalNode IF_P(int i) { + return getToken(PostgreSqlParser.IF_P, i); + } + public Expr_until_thenContext expr_until_then() { + return getRuleContext(Expr_until_thenContext.class,0); + } + public TerminalNode THEN() { return getToken(PostgreSqlParser.THEN, 0); } + public Proc_sectContext proc_sect() { + return getRuleContext(Proc_sectContext.class,0); + } + public Stmt_elsifsContext stmt_elsifs() { + return getRuleContext(Stmt_elsifsContext.class,0); + } + public Stmt_elseContext stmt_else() { + return getRuleContext(Stmt_elseContext.class,0); + } + public TerminalNode END_P() { return getToken(PostgreSqlParser.END_P, 0); } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_ifContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_if; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_if(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_if(this); + } + } + + public final Stmt_ifContext stmt_if() throws RecognitionException { + Stmt_ifContext _localctx = new Stmt_ifContext(_ctx, getState()); + enterRule(_localctx, 1478, RULE_stmt_if); + try { + enterOuterAlt(_localctx, 1); + { + setState(10219); + match(IF_P); + setState(10220); + expr_until_then(); + setState(10221); + match(THEN); + setState(10222); + proc_sect(); + setState(10223); + stmt_elsifs(); + setState(10224); + stmt_else(); + setState(10225); + match(END_P); + setState(10226); + match(IF_P); + setState(10227); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_elsifsContext extends ParserRuleContext { + public List ELSIF() { return getTokens(PostgreSqlParser.ELSIF); } + public TerminalNode ELSIF(int i) { + return getToken(PostgreSqlParser.ELSIF, i); + } + public List a_expr() { + return getRuleContexts(A_exprContext.class); + } + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public List THEN() { return getTokens(PostgreSqlParser.THEN); } + public TerminalNode THEN(int i) { + return getToken(PostgreSqlParser.THEN, i); + } + public List proc_sect() { + return getRuleContexts(Proc_sectContext.class); + } + public Proc_sectContext proc_sect(int i) { + return getRuleContext(Proc_sectContext.class,i); + } + public Stmt_elsifsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_elsifs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_elsifs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_elsifs(this); + } + } + + public final Stmt_elsifsContext stmt_elsifs() throws RecognitionException { + Stmt_elsifsContext _localctx = new Stmt_elsifsContext(_ctx, getState()); + enterRule(_localctx, 1480, RULE_stmt_elsifs); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10236); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ELSIF) { + { + { + setState(10229); + match(ELSIF); + setState(10230); + a_expr(); + setState(10231); + match(THEN); + setState(10232); + proc_sect(); + } + } + setState(10238); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_elseContext extends ParserRuleContext { + public TerminalNode ELSE() { return getToken(PostgreSqlParser.ELSE, 0); } + public Proc_sectContext proc_sect() { + return getRuleContext(Proc_sectContext.class,0); + } + public Stmt_elseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_else; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_else(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_else(this); + } + } + + public final Stmt_elseContext stmt_else() throws RecognitionException { + Stmt_elseContext _localctx = new Stmt_elseContext(_ctx, getState()); + enterRule(_localctx, 1482, RULE_stmt_else); + try { + setState(10242); + _errHandler.sync(this); + switch (_input.LA(1)) { + case END_P: + enterOuterAlt(_localctx, 1); + { + } + break; + case ELSE: + enterOuterAlt(_localctx, 2); + { + setState(10240); + match(ELSE); + setState(10241); + proc_sect(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_caseContext extends ParserRuleContext { + public List CASE() { return getTokens(PostgreSqlParser.CASE); } + public TerminalNode CASE(int i) { + return getToken(PostgreSqlParser.CASE, i); + } + public Opt_expr_until_whenContext opt_expr_until_when() { + return getRuleContext(Opt_expr_until_whenContext.class,0); + } + public Case_when_listContext case_when_list() { + return getRuleContext(Case_when_listContext.class,0); + } + public Opt_case_elseContext opt_case_else() { + return getRuleContext(Opt_case_elseContext.class,0); + } + public TerminalNode END_P() { return getToken(PostgreSqlParser.END_P, 0); } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_caseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_case; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_case(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_case(this); + } + } + + public final Stmt_caseContext stmt_case() throws RecognitionException { + Stmt_caseContext _localctx = new Stmt_caseContext(_ctx, getState()); + enterRule(_localctx, 1484, RULE_stmt_case); + try { + enterOuterAlt(_localctx, 1); + { + setState(10244); + match(CASE); + setState(10245); + opt_expr_until_when(); + setState(10246); + case_when_list(); + setState(10247); + opt_case_else(); + setState(10248); + match(END_P); + setState(10249); + match(CASE); + setState(10250); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_expr_until_whenContext extends ParserRuleContext { + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public Opt_expr_until_whenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_expr_until_when; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_expr_until_when(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_expr_until_when(this); + } + } + + public final Opt_expr_until_whenContext opt_expr_until_when() throws RecognitionException { + Opt_expr_until_whenContext _localctx = new Opt_expr_until_whenContext(_ctx, getState()); + enterRule(_localctx, 1486, RULE_opt_expr_until_when); + try { + setState(10254); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,694,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10253); + sql_expression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Case_when_listContext extends ParserRuleContext { + public List case_when() { + return getRuleContexts(Case_whenContext.class); + } + public Case_whenContext case_when(int i) { + return getRuleContext(Case_whenContext.class,i); + } + public Case_when_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_case_when_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCase_when_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCase_when_list(this); + } + } + + public final Case_when_listContext case_when_list() throws RecognitionException { + Case_when_listContext _localctx = new Case_when_listContext(_ctx, getState()); + enterRule(_localctx, 1488, RULE_case_when_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10257); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(10256); + case_when(); + } + } + setState(10259); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHEN ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Case_whenContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public TerminalNode THEN() { return getToken(PostgreSqlParser.THEN, 0); } + public Proc_sectContext proc_sect() { + return getRuleContext(Proc_sectContext.class,0); + } + public Case_whenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_case_when; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCase_when(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCase_when(this); + } + } + + public final Case_whenContext case_when() throws RecognitionException { + Case_whenContext _localctx = new Case_whenContext(_ctx, getState()); + enterRule(_localctx, 1490, RULE_case_when); + try { + enterOuterAlt(_localctx, 1); + { + setState(10261); + match(WHEN); + setState(10262); + expr_list(); + setState(10263); + match(THEN); + setState(10264); + proc_sect(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_case_elseContext extends ParserRuleContext { + public TerminalNode ELSE() { return getToken(PostgreSqlParser.ELSE, 0); } + public Proc_sectContext proc_sect() { + return getRuleContext(Proc_sectContext.class,0); + } + public Opt_case_elseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_case_else; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_case_else(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_case_else(this); + } + } + + public final Opt_case_elseContext opt_case_else() throws RecognitionException { + Opt_case_elseContext _localctx = new Opt_case_elseContext(_ctx, getState()); + enterRule(_localctx, 1492, RULE_opt_case_else); + try { + setState(10269); + _errHandler.sync(this); + switch (_input.LA(1)) { + case END_P: + enterOuterAlt(_localctx, 1); + { + } + break; + case ELSE: + enterOuterAlt(_localctx, 2); + { + setState(10267); + match(ELSE); + setState(10268); + proc_sect(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_loopContext extends ParserRuleContext { + public Opt_loop_labelContext opt_loop_label() { + return getRuleContext(Opt_loop_labelContext.class,0); + } + public Loop_bodyContext loop_body() { + return getRuleContext(Loop_bodyContext.class,0); + } + public Stmt_loopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_loop; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_loop(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_loop(this); + } + } + + public final Stmt_loopContext stmt_loop() throws RecognitionException { + Stmt_loopContext _localctx = new Stmt_loopContext(_ctx, getState()); + enterRule(_localctx, 1494, RULE_stmt_loop); + try { + enterOuterAlt(_localctx, 1); + { + setState(10271); + opt_loop_label(); + setState(10272); + loop_body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_whileContext extends ParserRuleContext { + public Opt_loop_labelContext opt_loop_label() { + return getRuleContext(Opt_loop_labelContext.class,0); + } + public TerminalNode WHILE() { return getToken(PostgreSqlParser.WHILE, 0); } + public Expr_until_loopContext expr_until_loop() { + return getRuleContext(Expr_until_loopContext.class,0); + } + public Loop_bodyContext loop_body() { + return getRuleContext(Loop_bodyContext.class,0); + } + public Stmt_whileContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_while; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_while(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_while(this); + } + } + + public final Stmt_whileContext stmt_while() throws RecognitionException { + Stmt_whileContext _localctx = new Stmt_whileContext(_ctx, getState()); + enterRule(_localctx, 1496, RULE_stmt_while); + try { + enterOuterAlt(_localctx, 1); + { + setState(10274); + opt_loop_label(); + setState(10275); + match(WHILE); + setState(10276); + expr_until_loop(); + setState(10277); + loop_body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_forContext extends ParserRuleContext { + public Opt_loop_labelContext opt_loop_label() { + return getRuleContext(Opt_loop_labelContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public For_controlContext for_control() { + return getRuleContext(For_controlContext.class,0); + } + public Loop_bodyContext loop_body() { + return getRuleContext(Loop_bodyContext.class,0); + } + public Stmt_forContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_for; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_for(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_for(this); + } + } + + public final Stmt_forContext stmt_for() throws RecognitionException { + Stmt_forContext _localctx = new Stmt_forContext(_ctx, getState()); + enterRule(_localctx, 1498, RULE_stmt_for); + try { + enterOuterAlt(_localctx, 1); + { + setState(10279); + opt_loop_label(); + setState(10280); + match(FOR); + setState(10281); + for_control(); + setState(10282); + loop_body(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class For_controlContext extends ParserRuleContext { + public For_variableContext for_variable() { + return getRuleContext(For_variableContext.class,0); + } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public Cursor_nameContext cursor_name() { + return getRuleContext(Cursor_nameContext.class,0); + } + public Opt_cursor_parametersContext opt_cursor_parameters() { + return getRuleContext(Opt_cursor_parametersContext.class,0); + } + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public ExplainstmtContext explainstmt() { + return getRuleContext(ExplainstmtContext.class,0); + } + public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } + public List a_expr() { + return getRuleContexts(A_exprContext.class); + } + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public Opt_for_using_expressionContext opt_for_using_expression() { + return getRuleContext(Opt_for_using_expressionContext.class,0); + } + public Opt_reverseContext opt_reverse() { + return getRuleContext(Opt_reverseContext.class,0); + } + public TerminalNode DOT_DOT() { return getToken(PostgreSqlParser.DOT_DOT, 0); } + public Opt_by_expressionContext opt_by_expression() { + return getRuleContext(Opt_by_expressionContext.class,0); + } + public For_controlContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for_control; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFor_control(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFor_control(this); + } + } + + public final For_controlContext for_control() throws RecognitionException { + For_controlContext _localctx = new For_controlContext(_ctx, getState()); + enterRule(_localctx, 1500, RULE_for_control); + try { + enterOuterAlt(_localctx, 1); + { + setState(10284); + for_variable(); + setState(10285); + match(IN_P); + setState(10301); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,697,_ctx) ) { + case 1: + { + setState(10286); + cursor_name(); + setState(10287); + opt_cursor_parameters(); + } + break; + case 2: + { + setState(10289); + selectstmt(); + } + break; + case 3: + { + setState(10290); + explainstmt(); } break; case 4: { - setState(5684); - type_name(); + setState(10291); + match(EXECUTE); + setState(10292); + a_expr(); + setState(10293); + opt_for_using_expression(); } break; case 5: { - setState(5685); - match(IDENTIFIER_UNICODE); + setState(10295); + opt_reverse(); + setState(10296); + a_expr(); + setState(10297); + match(DOT_DOT); + setState(10298); + a_expr(); + setState(10299); + opt_by_expression(); } break; } - _ctx.stop = _input.LT(-1); - setState(5693); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_for_using_expressionContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Opt_for_using_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_for_using_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_for_using_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_for_using_expression(this); + } + } + + public final Opt_for_using_expressionContext opt_for_using_expression() throws RecognitionException { + Opt_for_using_expressionContext _localctx = new Opt_for_using_expressionContext(_ctx, getState()); + enterRule(_localctx, 1502, RULE_opt_for_using_expression); + try { + setState(10306); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,701,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - if ( _parseListeners!=null ) triggerExitRuleEvent(); - _prevctx = _localctx; - { - { - _localctx = new IdentifierContext(_parentctx, _parentState); - pushNewRecursionContext(_localctx, _startState, RULE_identifier); - setState(5688); - if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(5689); - match(DOT); - setState(5690); - identifier(4); - } - } + switch (_input.LA(1)) { + case SEMI: + case LOOP: + enterOuterAlt(_localctx, 1); + { } - setState(5695); + break; + case USING: + enterOuterAlt(_localctx, 2); + { + setState(10304); + match(USING); + setState(10305); + expr_list(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_cursor_parametersContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public List a_expr() { + return getRuleContexts(A_exprContext.class); + } + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Opt_cursor_parametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_cursor_parameters; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_cursor_parameters(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_cursor_parameters(this); + } + } + + public final Opt_cursor_parametersContext opt_cursor_parameters() throws RecognitionException { + Opt_cursor_parametersContext _localctx = new Opt_cursor_parametersContext(_ctx, getState()); + enterRule(_localctx, 1504, RULE_opt_cursor_parameters); + int _la; + try { + setState(10320); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LOOP: + enterOuterAlt(_localctx, 1); + { + } + break; + case OPEN_PAREN: + enterOuterAlt(_localctx, 2); + { + setState(10309); + match(OPEN_PAREN); + setState(10310); + a_expr(); + setState(10315); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,701,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - @SuppressWarnings("CheckReturnValue") - public static class Todo_fill_inContext extends ParserRuleContext { - public Todo_fill_inContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_todo_fill_in; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTodo_fill_in(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTodo_fill_in(this); - } - } - - public final Todo_fill_inContext todo_fill_in() throws RecognitionException { - Todo_fill_inContext _localctx = new Todo_fill_inContext(_ctx, getState()); - enterRule(_localctx, 530, RULE_todo_fill_in); - try { - enterOuterAlt(_localctx, 1); - { - setState(5696); - matchWildcard(); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(10311); + match(COMMA); + setState(10312); + a_expr(); + } + } + setState(10317); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(10318); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -48172,32 +93272,41 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Todo_implementContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Todo_implementContext(ParserRuleContext parent, int invokingState) { + public static class Opt_reverseContext extends ParserRuleContext { + public TerminalNode REVERSE() { return getToken(PostgreSqlParser.REVERSE, 0); } + public Opt_reverseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_todo_implement; } + @Override public int getRuleIndex() { return RULE_opt_reverse; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTodo_implement(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_reverse(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTodo_implement(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_reverse(this); } } - public final Todo_implementContext todo_implement() throws RecognitionException { - Todo_implementContext _localctx = new Todo_implementContext(_ctx, getState()); - enterRule(_localctx, 532, RULE_todo_implement); + public final Opt_reverseContext opt_reverse() throws RecognitionException { + Opt_reverseContext _localctx = new Opt_reverseContext(_ctx, getState()); + enterRule(_localctx, 1506, RULE_opt_reverse); try { - enterOuterAlt(_localctx, 1); - { - setState(5698); - identifier(0); + setState(10324); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,701,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10323); + match(REVERSE); + } + break; } } catch (RecognitionException re) { @@ -48212,32 +93321,48 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Correlation_nameContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public static class Opt_by_expressionContext extends ParserRuleContext { + public TerminalNode BY() { return getToken(PostgreSqlParser.BY, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); } - public Correlation_nameContext(ParserRuleContext parent, int invokingState) { + public Opt_by_expressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_correlation_name; } + @Override public int getRuleIndex() { return RULE_opt_by_expression; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCorrelation_name(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_by_expression(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCorrelation_name(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_by_expression(this); } } - public final Correlation_nameContext correlation_name() throws RecognitionException { - Correlation_nameContext _localctx = new Correlation_nameContext(_ctx, getState()); - enterRule(_localctx, 534, RULE_correlation_name); + public final Opt_by_expressionContext opt_by_expression() throws RecognitionException { + Opt_by_expressionContext _localctx = new Opt_by_expressionContext(_ctx, getState()); + enterRule(_localctx, 1508, RULE_opt_by_expression); try { - enterOuterAlt(_localctx, 1); - { - setState(5700); - identifier(0); + setState(10329); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LOOP: + enterOuterAlt(_localctx, 1); + { + } + break; + case BY: + enterOuterAlt(_localctx, 2); + { + setState(10327); + match(BY); + setState(10328); + a_expr(); + } + break; + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -48252,32 +93377,32 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Column_nameContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public static class For_variableContext extends ParserRuleContext { + public Any_name_listContext any_name_list() { + return getRuleContext(Any_name_listContext.class,0); } - public Column_nameContext(ParserRuleContext parent, int invokingState) { + public For_variableContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_column_name; } + @Override public int getRuleIndex() { return RULE_for_variable; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_name(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFor_variable(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_name(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFor_variable(this); } } - public final Column_nameContext column_name() throws RecognitionException { - Column_nameContext _localctx = new Column_nameContext(_ctx, getState()); - enterRule(_localctx, 536, RULE_column_name); + public final For_variableContext for_variable() throws RecognitionException { + For_variableContext _localctx = new For_variableContext(_ctx, getState()); + enterRule(_localctx, 1510, RULE_for_variable); try { enterOuterAlt(_localctx, 1); { - setState(5702); - identifier(0); + setState(10331); + any_name_list(); } } catch (RecognitionException re) { @@ -48292,32 +93417,61 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class AliasContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public static class Stmt_foreach_aContext extends ParserRuleContext { + public Opt_loop_labelContext opt_loop_label() { + return getRuleContext(Opt_loop_labelContext.class,0); } - public AliasContext(ParserRuleContext parent, int invokingState) { + public TerminalNode FOREACH() { return getToken(PostgreSqlParser.FOREACH, 0); } + public For_variableContext for_variable() { + return getRuleContext(For_variableContext.class,0); + } + public Foreach_sliceContext foreach_slice() { + return getRuleContext(Foreach_sliceContext.class,0); + } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public TerminalNode ARRAY() { return getToken(PostgreSqlParser.ARRAY, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Loop_bodyContext loop_body() { + return getRuleContext(Loop_bodyContext.class,0); + } + public Stmt_foreach_aContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_alias; } + @Override public int getRuleIndex() { return RULE_stmt_foreach_a; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlias(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_foreach_a(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlias(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_foreach_a(this); } } - public final AliasContext alias() throws RecognitionException { - AliasContext _localctx = new AliasContext(_ctx, getState()); - enterRule(_localctx, 538, RULE_alias); + public final Stmt_foreach_aContext stmt_foreach_a() throws RecognitionException { + Stmt_foreach_aContext _localctx = new Stmt_foreach_aContext(_ctx, getState()); + enterRule(_localctx, 1512, RULE_stmt_foreach_a); try { enterOuterAlt(_localctx, 1); { - setState(5704); - identifier(0); + setState(10333); + opt_loop_label(); + setState(10334); + match(FOREACH); + setState(10335); + for_variable(); + setState(10336); + foreach_slice(); + setState(10337); + match(IN_P); + setState(10338); + match(ARRAY); + setState(10339); + a_expr(); + setState(10340); + loop_body(); } } catch (RecognitionException re) { @@ -48332,32 +93486,48 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Column_aliasContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public static class Foreach_sliceContext extends ParserRuleContext { + public TerminalNode SLICE() { return getToken(PostgreSqlParser.SLICE, 0); } + public IconstContext iconst() { + return getRuleContext(IconstContext.class,0); } - public Column_aliasContext(ParserRuleContext parent, int invokingState) { + public Foreach_sliceContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_column_alias; } + @Override public int getRuleIndex() { return RULE_foreach_slice; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_alias(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterForeach_slice(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_alias(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitForeach_slice(this); } } - public final Column_aliasContext column_alias() throws RecognitionException { - Column_aliasContext _localctx = new Column_aliasContext(_ctx, getState()); - enterRule(_localctx, 540, RULE_column_alias); + public final Foreach_sliceContext foreach_slice() throws RecognitionException { + Foreach_sliceContext _localctx = new Foreach_sliceContext(_ctx, getState()); + enterRule(_localctx, 1514, RULE_foreach_slice); try { - enterOuterAlt(_localctx, 1); - { - setState(5706); - identifier(0); + setState(10345); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IN_P: + enterOuterAlt(_localctx, 1); + { + } + break; + case SLICE: + enterOuterAlt(_localctx, 2); + { + setState(10343); + match(SLICE); + setState(10344); + iconst(); + } + break; + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -48372,32 +93542,45 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Column_definitionContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); + public static class Stmt_exitContext extends ParserRuleContext { + public Exit_typeContext exit_type() { + return getRuleContext(Exit_typeContext.class,0); } - public Column_definitionContext(ParserRuleContext parent, int invokingState) { + public Opt_labelContext opt_label() { + return getRuleContext(Opt_labelContext.class,0); + } + public Opt_exitcondContext opt_exitcond() { + return getRuleContext(Opt_exitcondContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_exitContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_column_definition; } + @Override public int getRuleIndex() { return RULE_stmt_exit; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_definition(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_exit(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_definition(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_exit(this); } } - public final Column_definitionContext column_definition() throws RecognitionException { - Column_definitionContext _localctx = new Column_definitionContext(_ctx, getState()); - enterRule(_localctx, 542, RULE_column_definition); + public final Stmt_exitContext stmt_exit() throws RecognitionException { + Stmt_exitContext _localctx = new Stmt_exitContext(_ctx, getState()); + enterRule(_localctx, 1516, RULE_stmt_exit); try { enterOuterAlt(_localctx, 1); { - setState(5708); - identifier(0); + setState(10347); + exit_type(); + setState(10348); + opt_label(); + setState(10349); + opt_exitcond(); + setState(10350); + match(SEMI); } } catch (RecognitionException re) { @@ -48412,32 +93595,5479 @@ public class PostgreSqlParser extends Parser { } @SuppressWarnings("CheckReturnValue") - public static class Window_nameContext extends ParserRuleContext { - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public Window_nameContext(ParserRuleContext parent, int invokingState) { + public static class Exit_typeContext extends ParserRuleContext { + public TerminalNode EXIT() { return getToken(PostgreSqlParser.EXIT, 0); } + public TerminalNode CONTINUE_P() { return getToken(PostgreSqlParser.CONTINUE_P, 0); } + public Exit_typeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - @Override public int getRuleIndex() { return RULE_window_name; } + @Override public int getRuleIndex() { return RULE_exit_type; } @Override public void enterRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWindow_name(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExit_type(this); } @Override public void exitRule(ParseTreeListener listener) { - if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWindow_name(this); + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExit_type(this); } } - public final Window_nameContext window_name() throws RecognitionException { - Window_nameContext _localctx = new Window_nameContext(_ctx, getState()); - enterRule(_localctx, 544, RULE_window_name); + public final Exit_typeContext exit_type() throws RecognitionException { + Exit_typeContext _localctx = new Exit_typeContext(_ctx, getState()); + enterRule(_localctx, 1518, RULE_exit_type); + int _la; try { enterOuterAlt(_localctx, 1); { - setState(5710); - identifier(0); + setState(10352); + _la = _input.LA(1); + if ( !(_la==CONTINUE_P || _la==EXIT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_returnContext extends ParserRuleContext { + public TerminalNode RETURN() { return getToken(PostgreSqlParser.RETURN, 0); } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public TerminalNode QUERY() { return getToken(PostgreSqlParser.QUERY, 0); } + public Opt_return_resultContext opt_return_result() { + return getRuleContext(Opt_return_resultContext.class,0); + } + public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Opt_for_using_expressionContext opt_for_using_expression() { + return getRuleContext(Opt_for_using_expressionContext.class,0); + } + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public Stmt_returnContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_return; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_return(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_return(this); + } + } + + public final Stmt_returnContext stmt_return() throws RecognitionException { + Stmt_returnContext _localctx = new Stmt_returnContext(_ctx, getState()); + enterRule(_localctx, 1520, RULE_stmt_return); + try { + enterOuterAlt(_localctx, 1); + { + setState(10354); + match(RETURN); + setState(10366); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,705,_ctx) ) { + case 1: + { + setState(10355); + match(NEXT); + setState(10356); + sql_expression(); + } + break; + case 2: + { + setState(10357); + match(QUERY); + setState(10363); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EXECUTE: + { + setState(10358); + match(EXECUTE); + setState(10359); + a_expr(); + setState(10360); + opt_for_using_expression(); + } + break; + case OPEN_PAREN: + case SELECT: + case TABLE: + case WITH: + case VALUES: + { + setState(10362); + selectstmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + { + setState(10365); + opt_return_result(); + } + break; + } + setState(10368); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_return_resultContext extends ParserRuleContext { + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public Opt_return_resultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_return_result; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_return_result(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_return_result(this); + } + } + + public final Opt_return_resultContext opt_return_result() throws RecognitionException { + Opt_return_resultContext _localctx = new Opt_return_resultContext(_ctx, getState()); + enterRule(_localctx, 1522, RULE_opt_return_result); + try { + setState(10372); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,706,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10371); + sql_expression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_raiseContext extends ParserRuleContext { + public TerminalNode RAISE() { return getToken(PostgreSqlParser.RAISE, 0); } + public Opt_stmt_raise_levelContext opt_stmt_raise_level() { + return getRuleContext(Opt_stmt_raise_levelContext.class,0); + } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Opt_raise_listContext opt_raise_list() { + return getRuleContext(Opt_raise_listContext.class,0); + } + public Opt_raise_usingContext opt_raise_using() { + return getRuleContext(Opt_raise_usingContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode SQLSTATE() { return getToken(PostgreSqlParser.SQLSTATE, 0); } + public Stmt_raiseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_raise; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_raise(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_raise(this); + } + } + + public final Stmt_raiseContext stmt_raise() throws RecognitionException { + Stmt_raiseContext _localctx = new Stmt_raiseContext(_ctx, getState()); + enterRule(_localctx, 1524, RULE_stmt_raise); + try { + setState(10400); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,707,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(10374); + match(RAISE); + setState(10375); + opt_stmt_raise_level(); + setState(10376); + sconst(); + setState(10377); + opt_raise_list(); + setState(10378); + opt_raise_using(); + setState(10379); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10381); + match(RAISE); + setState(10382); + opt_stmt_raise_level(); + setState(10383); + identifier(); + setState(10384); + opt_raise_using(); + setState(10385); + match(SEMI); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(10387); + match(RAISE); + setState(10388); + opt_stmt_raise_level(); + setState(10389); + match(SQLSTATE); + setState(10390); + sconst(); + setState(10391); + opt_raise_using(); + setState(10392); + match(SEMI); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(10394); + match(RAISE); + setState(10395); + opt_stmt_raise_level(); + setState(10396); + opt_raise_using(); + setState(10397); + match(SEMI); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(10399); + match(RAISE); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_stmt_raise_levelContext extends ParserRuleContext { + public TerminalNode DEBUG() { return getToken(PostgreSqlParser.DEBUG, 0); } + public TerminalNode LOG() { return getToken(PostgreSqlParser.LOG, 0); } + public TerminalNode INFO() { return getToken(PostgreSqlParser.INFO, 0); } + public TerminalNode NOTICE() { return getToken(PostgreSqlParser.NOTICE, 0); } + public TerminalNode WARNING() { return getToken(PostgreSqlParser.WARNING, 0); } + public TerminalNode EXCEPTION() { return getToken(PostgreSqlParser.EXCEPTION, 0); } + public Opt_stmt_raise_levelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_stmt_raise_level; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_stmt_raise_level(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_stmt_raise_level(this); + } + } + + public final Opt_stmt_raise_levelContext opt_stmt_raise_level() throws RecognitionException { + Opt_stmt_raise_levelContext _localctx = new Opt_stmt_raise_levelContext(_ctx, getState()); + enterRule(_localctx, 1526, RULE_opt_stmt_raise_level); + try { + setState(10410); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,708,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(10404); + match(DEBUG); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(10405); + match(LOG); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(10406); + match(INFO); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(10407); + match(NOTICE); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(10408); + match(WARNING); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(10409); + match(EXCEPTION); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_raise_listContext extends ParserRuleContext { + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public List a_expr() { + return getRuleContexts(A_exprContext.class); + } + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public Opt_raise_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_raise_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_raise_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_raise_list(this); + } + } + + public final Opt_raise_listContext opt_raise_list() throws RecognitionException { + Opt_raise_listContext _localctx = new Opt_raise_listContext(_ctx, getState()); + enterRule(_localctx, 1528, RULE_opt_raise_list); + int _la; + try { + setState(10419); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + case USING: + enterOuterAlt(_localctx, 1); + { + } + break; + case COMMA: + enterOuterAlt(_localctx, 2); + { + setState(10415); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(10413); + match(COMMA); + setState(10414); + a_expr(); + } + } + setState(10417); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==COMMA ); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_raise_usingContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public Opt_raise_using_elem_listContext opt_raise_using_elem_list() { + return getRuleContext(Opt_raise_using_elem_listContext.class,0); + } + public Opt_raise_usingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_raise_using; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_raise_using(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_raise_using(this); + } + } + + public final Opt_raise_usingContext opt_raise_using() throws RecognitionException { + Opt_raise_usingContext _localctx = new Opt_raise_usingContext(_ctx, getState()); + enterRule(_localctx, 1530, RULE_opt_raise_using); + try { + setState(10424); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + enterOuterAlt(_localctx, 1); + { + } + break; + case USING: + enterOuterAlt(_localctx, 2); + { + setState(10422); + match(USING); + setState(10423); + opt_raise_using_elem_list(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_raise_using_elemContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode EQUAL() { return getToken(PostgreSqlParser.EQUAL, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Opt_raise_using_elemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_raise_using_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_raise_using_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_raise_using_elem(this); + } + } + + public final Opt_raise_using_elemContext opt_raise_using_elem() throws RecognitionException { + Opt_raise_using_elemContext _localctx = new Opt_raise_using_elemContext(_ctx, getState()); + enterRule(_localctx, 1532, RULE_opt_raise_using_elem); + try { + enterOuterAlt(_localctx, 1); + { + setState(10426); + identifier(); + setState(10427); + match(EQUAL); + setState(10428); + a_expr(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_raise_using_elem_listContext extends ParserRuleContext { + public List opt_raise_using_elem() { + return getRuleContexts(Opt_raise_using_elemContext.class); + } + public Opt_raise_using_elemContext opt_raise_using_elem(int i) { + return getRuleContext(Opt_raise_using_elemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Opt_raise_using_elem_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_raise_using_elem_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_raise_using_elem_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_raise_using_elem_list(this); + } + } + + public final Opt_raise_using_elem_listContext opt_raise_using_elem_list() throws RecognitionException { + Opt_raise_using_elem_listContext _localctx = new Opt_raise_using_elem_listContext(_ctx, getState()); + enterRule(_localctx, 1534, RULE_opt_raise_using_elem_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10430); + opt_raise_using_elem(); + setState(10435); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(10431); + match(COMMA); + setState(10432); + opt_raise_using_elem(); + } + } + setState(10437); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_assertContext extends ParserRuleContext { + public TerminalNode ASSERT() { return getToken(PostgreSqlParser.ASSERT, 0); } + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public Opt_stmt_assert_messageContext opt_stmt_assert_message() { + return getRuleContext(Opt_stmt_assert_messageContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_assertContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_assert; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_assert(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_assert(this); + } + } + + public final Stmt_assertContext stmt_assert() throws RecognitionException { + Stmt_assertContext _localctx = new Stmt_assertContext(_ctx, getState()); + enterRule(_localctx, 1536, RULE_stmt_assert); + try { + enterOuterAlt(_localctx, 1); + { + setState(10438); + match(ASSERT); + setState(10439); + sql_expression(); + setState(10440); + opt_stmt_assert_message(); + setState(10441); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_stmt_assert_messageContext extends ParserRuleContext { + public TerminalNode COMMA() { return getToken(PostgreSqlParser.COMMA, 0); } + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public Opt_stmt_assert_messageContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_stmt_assert_message; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_stmt_assert_message(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_stmt_assert_message(this); + } + } + + public final Opt_stmt_assert_messageContext opt_stmt_assert_message() throws RecognitionException { + Opt_stmt_assert_messageContext _localctx = new Opt_stmt_assert_messageContext(_ctx, getState()); + enterRule(_localctx, 1538, RULE_opt_stmt_assert_message); + try { + setState(10446); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + enterOuterAlt(_localctx, 1); + { + } + break; + case COMMA: + enterOuterAlt(_localctx, 2); + { + setState(10444); + match(COMMA); + setState(10445); + sql_expression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Loop_bodyContext extends ParserRuleContext { + public List LOOP() { return getTokens(PostgreSqlParser.LOOP); } + public TerminalNode LOOP(int i) { + return getToken(PostgreSqlParser.LOOP, i); + } + public Proc_sectContext proc_sect() { + return getRuleContext(Proc_sectContext.class,0); + } + public TerminalNode END_P() { return getToken(PostgreSqlParser.END_P, 0); } + public Opt_labelContext opt_label() { + return getRuleContext(Opt_labelContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Loop_bodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_loop_body; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterLoop_body(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitLoop_body(this); + } + } + + public final Loop_bodyContext loop_body() throws RecognitionException { + Loop_bodyContext _localctx = new Loop_bodyContext(_ctx, getState()); + enterRule(_localctx, 1540, RULE_loop_body); + try { + enterOuterAlt(_localctx, 1); + { + setState(10448); + match(LOOP); + setState(10449); + proc_sect(); + setState(10450); + match(END_P); + setState(10451); + match(LOOP); + setState(10452); + opt_label(); + setState(10453); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_execsqlContext extends ParserRuleContext { + public Make_execsql_stmtContext make_execsql_stmt() { + return getRuleContext(Make_execsql_stmtContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_execsqlContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_execsql; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_execsql(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_execsql(this); + } + } + + public final Stmt_execsqlContext stmt_execsql() throws RecognitionException { + Stmt_execsqlContext _localctx = new Stmt_execsqlContext(_ctx, getState()); + enterRule(_localctx, 1542, RULE_stmt_execsql); + try { + enterOuterAlt(_localctx, 1); + { + setState(10455); + make_execsql_stmt(); + setState(10456); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_dynexecuteContext extends ParserRuleContext { + public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Opt_execute_intoContext opt_execute_into() { + return getRuleContext(Opt_execute_intoContext.class,0); + } + public Opt_execute_usingContext opt_execute_using() { + return getRuleContext(Opt_execute_usingContext.class,0); + } + public Stmt_dynexecuteContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_dynexecute; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_dynexecute(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_dynexecute(this); + } + } + + public final Stmt_dynexecuteContext stmt_dynexecute() throws RecognitionException { + Stmt_dynexecuteContext _localctx = new Stmt_dynexecuteContext(_ctx, getState()); + enterRule(_localctx, 1544, RULE_stmt_dynexecute); + try { + enterOuterAlt(_localctx, 1); + { + setState(10458); + match(EXECUTE); + setState(10459); + a_expr(); + setState(10467); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,714,_ctx) ) { + case 1: + { + setState(10460); + opt_execute_into(); + setState(10461); + opt_execute_using(); + } + break; + case 2: + { + setState(10463); + opt_execute_using(); + setState(10464); + opt_execute_into(); + } + break; + case 3: + { + } + break; + } + setState(10469); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_execute_usingContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public Opt_execute_using_listContext opt_execute_using_list() { + return getRuleContext(Opt_execute_using_listContext.class,0); + } + public Opt_execute_usingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_execute_using; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_execute_using(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_execute_using(this); + } + } + + public final Opt_execute_usingContext opt_execute_using() throws RecognitionException { + Opt_execute_usingContext _localctx = new Opt_execute_usingContext(_ctx, getState()); + enterRule(_localctx, 1546, RULE_opt_execute_using); + try { + setState(10474); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + case INTO: + enterOuterAlt(_localctx, 1); + { + } + break; + case USING: + enterOuterAlt(_localctx, 2); + { + setState(10472); + match(USING); + setState(10473); + opt_execute_using_list(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_execute_using_listContext extends ParserRuleContext { + public List a_expr() { + return getRuleContexts(A_exprContext.class); + } + public A_exprContext a_expr(int i) { + return getRuleContext(A_exprContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Opt_execute_using_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_execute_using_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_execute_using_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_execute_using_list(this); + } + } + + public final Opt_execute_using_listContext opt_execute_using_list() throws RecognitionException { + Opt_execute_using_listContext _localctx = new Opt_execute_using_listContext(_ctx, getState()); + enterRule(_localctx, 1548, RULE_opt_execute_using_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10476); + a_expr(); + setState(10481); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(10477); + match(COMMA); + setState(10478); + a_expr(); + } + } + setState(10483); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_execute_intoContext extends ParserRuleContext { + public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } + public Into_targetContext into_target() { + return getRuleContext(Into_targetContext.class,0); + } + public TerminalNode STRICT_P() { return getToken(PostgreSqlParser.STRICT_P, 0); } + public Opt_execute_intoContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_execute_into; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_execute_into(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_execute_into(this); + } + } + + public final Opt_execute_intoContext opt_execute_into() throws RecognitionException { + Opt_execute_intoContext _localctx = new Opt_execute_intoContext(_ctx, getState()); + enterRule(_localctx, 1550, RULE_opt_execute_into); + try { + setState(10490); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + case USING: + enterOuterAlt(_localctx, 1); + { + } + break; + case INTO: + enterOuterAlt(_localctx, 2); + { + setState(10485); + match(INTO); + setState(10487); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,717,_ctx) ) { + case 1: + { + setState(10486); + match(STRICT_P); + } + break; + } + setState(10489); + into_target(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_openContext extends ParserRuleContext { + public TerminalNode OPEN() { return getToken(PostgreSqlParser.OPEN, 0); } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Cursor_variableContext cursor_variable() { + return getRuleContext(Cursor_variableContext.class,0); + } + public Opt_scroll_optionContext opt_scroll_option() { + return getRuleContext(Opt_scroll_optionContext.class,0); + } + public TerminalNode FOR() { return getToken(PostgreSqlParser.FOR, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public SelectstmtContext selectstmt() { + return getRuleContext(SelectstmtContext.class,0); + } + public TerminalNode EXECUTE() { return getToken(PostgreSqlParser.EXECUTE, 0); } + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public Opt_open_usingContext opt_open_using() { + return getRuleContext(Opt_open_usingContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Opt_open_bound_listContext opt_open_bound_list() { + return getRuleContext(Opt_open_bound_listContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public Stmt_openContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_open; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_open(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_open(this); + } + } + + public final Stmt_openContext stmt_open() throws RecognitionException { + Stmt_openContext _localctx = new Stmt_openContext(_ctx, getState()); + enterRule(_localctx, 1552, RULE_stmt_open); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10492); + match(OPEN); + setState(10510); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,721,_ctx) ) { + case 1: + { + setState(10493); + cursor_variable(); + setState(10494); + opt_scroll_option(); + setState(10495); + match(FOR); + setState(10501); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + case SELECT: + case TABLE: + case WITH: + case VALUES: + { + setState(10496); + selectstmt(); + } + break; + case EXECUTE: + { + setState(10497); + match(EXECUTE); + setState(10498); + sql_expression(); + setState(10499); + opt_open_using(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + { + setState(10503); + colid(); + setState(10508); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(10504); + match(OPEN_PAREN); + setState(10505); + opt_open_bound_list(); + setState(10506); + match(CLOSE_PAREN); + } + } + + } + break; + } + setState(10512); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_open_bound_list_itemContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode COLON_EQUALS() { return getToken(PostgreSqlParser.COLON_EQUALS, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Opt_open_bound_list_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_open_bound_list_item; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_open_bound_list_item(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_open_bound_list_item(this); + } + } + + public final Opt_open_bound_list_itemContext opt_open_bound_list_item() throws RecognitionException { + Opt_open_bound_list_itemContext _localctx = new Opt_open_bound_list_itemContext(_ctx, getState()); + enterRule(_localctx, 1554, RULE_opt_open_bound_list_item); + try { + setState(10519); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,722,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(10514); + colid(); + setState(10515); + match(COLON_EQUALS); + setState(10516); + a_expr(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10518); + a_expr(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_open_bound_listContext extends ParserRuleContext { + public List opt_open_bound_list_item() { + return getRuleContexts(Opt_open_bound_list_itemContext.class); + } + public Opt_open_bound_list_itemContext opt_open_bound_list_item(int i) { + return getRuleContext(Opt_open_bound_list_itemContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Opt_open_bound_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_open_bound_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_open_bound_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_open_bound_list(this); + } + } + + public final Opt_open_bound_listContext opt_open_bound_list() throws RecognitionException { + Opt_open_bound_listContext _localctx = new Opt_open_bound_listContext(_ctx, getState()); + enterRule(_localctx, 1556, RULE_opt_open_bound_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10521); + opt_open_bound_list_item(); + setState(10526); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(10522); + match(COMMA); + setState(10523); + opt_open_bound_list_item(); + } + } + setState(10528); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_open_usingContext extends ParserRuleContext { + public TerminalNode USING() { return getToken(PostgreSqlParser.USING, 0); } + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Opt_open_usingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_open_using; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_open_using(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_open_using(this); + } + } + + public final Opt_open_usingContext opt_open_using() throws RecognitionException { + Opt_open_usingContext _localctx = new Opt_open_usingContext(_ctx, getState()); + enterRule(_localctx, 1558, RULE_opt_open_using); + try { + setState(10532); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SEMI: + enterOuterAlt(_localctx, 1); + { + } + break; + case USING: + enterOuterAlt(_localctx, 2); + { + setState(10530); + match(USING); + setState(10531); + expr_list(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_scroll_optionContext extends ParserRuleContext { + public Opt_scroll_option_noContext opt_scroll_option_no() { + return getRuleContext(Opt_scroll_option_noContext.class,0); + } + public TerminalNode SCROLL() { return getToken(PostgreSqlParser.SCROLL, 0); } + public Opt_scroll_optionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_scroll_option; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_scroll_option(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_scroll_option(this); + } + } + + public final Opt_scroll_optionContext opt_scroll_option() throws RecognitionException { + Opt_scroll_optionContext _localctx = new Opt_scroll_optionContext(_ctx, getState()); + enterRule(_localctx, 1560, RULE_opt_scroll_option); + try { + setState(10538); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + } + break; + case NO: + case SCROLL: + enterOuterAlt(_localctx, 2); + { + setState(10535); + opt_scroll_option_no(); + setState(10536); + match(SCROLL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_scroll_option_noContext extends ParserRuleContext { + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public Opt_scroll_option_noContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_scroll_option_no; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_scroll_option_no(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_scroll_option_no(this); + } + } + + public final Opt_scroll_option_noContext opt_scroll_option_no() throws RecognitionException { + Opt_scroll_option_noContext _localctx = new Opt_scroll_option_noContext(_ctx, getState()); + enterRule(_localctx, 1562, RULE_opt_scroll_option_no); + try { + setState(10542); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SCROLL: + enterOuterAlt(_localctx, 1); + { + } + break; + case NO: + enterOuterAlt(_localctx, 2); + { + setState(10541); + match(NO); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_fetchContext extends ParserRuleContext { + public Opt_fetch_directionContext direction; + public TerminalNode FETCH() { return getToken(PostgreSqlParser.FETCH, 0); } + public Opt_cursor_fromContext opt_cursor_from() { + return getRuleContext(Opt_cursor_fromContext.class,0); + } + public Cursor_variableContext cursor_variable() { + return getRuleContext(Cursor_variableContext.class,0); + } + public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } + public Into_targetContext into_target() { + return getRuleContext(Into_targetContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Opt_fetch_directionContext opt_fetch_direction() { + return getRuleContext(Opt_fetch_directionContext.class,0); + } + public Stmt_fetchContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_fetch; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_fetch(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_fetch(this); + } + } + + public final Stmt_fetchContext stmt_fetch() throws RecognitionException { + Stmt_fetchContext _localctx = new Stmt_fetchContext(_ctx, getState()); + enterRule(_localctx, 1564, RULE_stmt_fetch); + try { + enterOuterAlt(_localctx, 1); + { + setState(10544); + match(FETCH); + setState(10545); + ((Stmt_fetchContext)_localctx).direction = opt_fetch_direction(); + setState(10546); + opt_cursor_from(); + setState(10547); + cursor_variable(); + setState(10548); + match(INTO); + setState(10549); + into_target(); + setState(10550); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Into_targetContext extends ParserRuleContext { + public Expr_listContext expr_list() { + return getRuleContext(Expr_listContext.class,0); + } + public Into_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_into_target; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterInto_target(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitInto_target(this); + } + } + + public final Into_targetContext into_target() throws RecognitionException { + Into_targetContext _localctx = new Into_targetContext(_ctx, getState()); + enterRule(_localctx, 1566, RULE_into_target); + try { + enterOuterAlt(_localctx, 1); + { + setState(10552); + expr_list(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_cursor_fromContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(PostgreSqlParser.FROM, 0); } + public TerminalNode IN_P() { return getToken(PostgreSqlParser.IN_P, 0); } + public Opt_cursor_fromContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_cursor_from; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_cursor_from(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_cursor_from(this); + } + } + + public final Opt_cursor_fromContext opt_cursor_from() throws RecognitionException { + Opt_cursor_fromContext _localctx = new Opt_cursor_fromContext(_ctx, getState()); + enterRule(_localctx, 1568, RULE_opt_cursor_from); + try { + setState(10557); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PARAM: + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + } + break; + case FROM: + enterOuterAlt(_localctx, 2); + { + setState(10555); + match(FROM); + } + break; + case IN_P: + enterOuterAlt(_localctx, 3); + { + setState(10556); + match(IN_P); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_fetch_directionContext extends ParserRuleContext { + public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } + public TerminalNode PRIOR() { return getToken(PostgreSqlParser.PRIOR, 0); } + public TerminalNode FIRST_P() { return getToken(PostgreSqlParser.FIRST_P, 0); } + public TerminalNode LAST_P() { return getToken(PostgreSqlParser.LAST_P, 0); } + public TerminalNode ABSOLUTE_P() { return getToken(PostgreSqlParser.ABSOLUTE_P, 0); } + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public TerminalNode RELATIVE_P() { return getToken(PostgreSqlParser.RELATIVE_P, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public TerminalNode FORWARD() { return getToken(PostgreSqlParser.FORWARD, 0); } + public TerminalNode BACKWARD() { return getToken(PostgreSqlParser.BACKWARD, 0); } + public Opt_fetch_directionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_fetch_direction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_fetch_direction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_fetch_direction(this); + } + } + + public final Opt_fetch_directionContext opt_fetch_direction() throws RecognitionException { + Opt_fetch_directionContext _localctx = new Opt_fetch_directionContext(_ctx, getState()); + enterRule(_localctx, 1570, RULE_opt_fetch_direction); + int _la; + try { + setState(10576); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,729,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(10561); + match(NEXT); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(10562); + match(PRIOR); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(10563); + match(FIRST_P); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(10564); + match(LAST_P); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(10565); + match(ABSOLUTE_P); + setState(10566); + a_expr(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(10567); + match(RELATIVE_P); + setState(10568); + a_expr(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(10569); + a_expr(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(10570); + match(ALL); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(10571); + _la = _input.LA(1); + if ( !(_la==BACKWARD || _la==FORWARD) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(10574); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,728,_ctx) ) { + case 1: + { + setState(10572); + a_expr(); + } + break; + case 2: + { + setState(10573); + match(ALL); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_moveContext extends ParserRuleContext { + public TerminalNode MOVE() { return getToken(PostgreSqlParser.MOVE, 0); } + public Opt_fetch_directionContext opt_fetch_direction() { + return getRuleContext(Opt_fetch_directionContext.class,0); + } + public Cursor_variableContext cursor_variable() { + return getRuleContext(Cursor_variableContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_moveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_move; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_move(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_move(this); + } + } + + public final Stmt_moveContext stmt_move() throws RecognitionException { + Stmt_moveContext _localctx = new Stmt_moveContext(_ctx, getState()); + enterRule(_localctx, 1572, RULE_stmt_move); + try { + enterOuterAlt(_localctx, 1); + { + setState(10578); + match(MOVE); + setState(10579); + opt_fetch_direction(); + setState(10580); + cursor_variable(); + setState(10581); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_closeContext extends ParserRuleContext { + public TerminalNode CLOSE() { return getToken(PostgreSqlParser.CLOSE, 0); } + public Cursor_variableContext cursor_variable() { + return getRuleContext(Cursor_variableContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_closeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_close; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_close(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_close(this); + } + } + + public final Stmt_closeContext stmt_close() throws RecognitionException { + Stmt_closeContext _localctx = new Stmt_closeContext(_ctx, getState()); + enterRule(_localctx, 1574, RULE_stmt_close); + try { + enterOuterAlt(_localctx, 1); + { + setState(10583); + match(CLOSE); + setState(10584); + cursor_variable(); + setState(10585); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_nullContext extends ParserRuleContext { + public TerminalNode NULL_P() { return getToken(PostgreSqlParser.NULL_P, 0); } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_nullContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_null; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_null(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_null(this); + } + } + + public final Stmt_nullContext stmt_null() throws RecognitionException { + Stmt_nullContext _localctx = new Stmt_nullContext(_ctx, getState()); + enterRule(_localctx, 1576, RULE_stmt_null); + try { + enterOuterAlt(_localctx, 1); + { + setState(10587); + match(NULL_P); + setState(10588); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_commitContext extends ParserRuleContext { + public TerminalNode COMMIT() { return getToken(PostgreSqlParser.COMMIT, 0); } + public Plsql_opt_transaction_chainContext plsql_opt_transaction_chain() { + return getRuleContext(Plsql_opt_transaction_chainContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_commitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_commit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_commit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_commit(this); + } + } + + public final Stmt_commitContext stmt_commit() throws RecognitionException { + Stmt_commitContext _localctx = new Stmt_commitContext(_ctx, getState()); + enterRule(_localctx, 1578, RULE_stmt_commit); + try { + enterOuterAlt(_localctx, 1); + { + setState(10590); + match(COMMIT); + setState(10591); + plsql_opt_transaction_chain(); + setState(10592); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_rollbackContext extends ParserRuleContext { + public TerminalNode ROLLBACK() { return getToken(PostgreSqlParser.ROLLBACK, 0); } + public Plsql_opt_transaction_chainContext plsql_opt_transaction_chain() { + return getRuleContext(Plsql_opt_transaction_chainContext.class,0); + } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public Stmt_rollbackContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_rollback; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_rollback(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_rollback(this); + } + } + + public final Stmt_rollbackContext stmt_rollback() throws RecognitionException { + Stmt_rollbackContext _localctx = new Stmt_rollbackContext(_ctx, getState()); + enterRule(_localctx, 1580, RULE_stmt_rollback); + try { + enterOuterAlt(_localctx, 1); + { + setState(10594); + match(ROLLBACK); + setState(10595); + plsql_opt_transaction_chain(); + setState(10596); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Plsql_opt_transaction_chainContext extends ParserRuleContext { + public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } + public TerminalNode CHAIN() { return getToken(PostgreSqlParser.CHAIN, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public Plsql_opt_transaction_chainContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_plsql_opt_transaction_chain; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPlsql_opt_transaction_chain(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPlsql_opt_transaction_chain(this); + } + } + + public final Plsql_opt_transaction_chainContext plsql_opt_transaction_chain() throws RecognitionException { + Plsql_opt_transaction_chainContext _localctx = new Plsql_opt_transaction_chainContext(_ctx, getState()); + enterRule(_localctx, 1582, RULE_plsql_opt_transaction_chain); + int _la; + try { + setState(10604); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + enterOuterAlt(_localctx, 1); + { + setState(10598); + match(AND); + setState(10600); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(10599); + match(NO); + } + } + + setState(10602); + match(CHAIN); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Stmt_setContext extends ParserRuleContext { + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public Any_nameContext any_name() { + return getRuleContext(Any_nameContext.class,0); + } + public TerminalNode TO() { return getToken(PostgreSqlParser.TO, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public TerminalNode SEMI() { return getToken(PostgreSqlParser.SEMI, 0); } + public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public Stmt_setContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt_set; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt_set(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt_set(this); + } + } + + public final Stmt_setContext stmt_set() throws RecognitionException { + Stmt_setContext _localctx = new Stmt_setContext(_ctx, getState()); + enterRule(_localctx, 1584, RULE_stmt_set); + try { + setState(10618); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SET: + enterOuterAlt(_localctx, 1); + { + setState(10606); + match(SET); + setState(10607); + any_name(); + setState(10608); + match(TO); + setState(10609); + match(DEFAULT); + setState(10610); + match(SEMI); + } + break; + case RESET: + enterOuterAlt(_localctx, 2); + { + setState(10612); + match(RESET); + setState(10615); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + { + setState(10613); + any_name(); + } + break; + case ALL: + { + setState(10614); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(10617); + match(SEMI); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cursor_variableContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public TerminalNode PARAM() { return getToken(PostgreSqlParser.PARAM, 0); } + public Cursor_variableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cursor_variable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCursor_variable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCursor_variable(this); + } + } + + public final Cursor_variableContext cursor_variable() throws RecognitionException { + Cursor_variableContext _localctx = new Cursor_variableContext(_ctx, getState()); + enterRule(_localctx, 1586, RULE_cursor_variable); + try { + setState(10622); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(10620); + colid(); + } + break; + case PARAM: + enterOuterAlt(_localctx, 2); + { + setState(10621); + match(PARAM); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Exception_sectContext extends ParserRuleContext { + public TerminalNode EXCEPTION() { return getToken(PostgreSqlParser.EXCEPTION, 0); } + public Proc_exceptionsContext proc_exceptions() { + return getRuleContext(Proc_exceptionsContext.class,0); + } + public Exception_sectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exception_sect; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterException_sect(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitException_sect(this); + } + } + + public final Exception_sectContext exception_sect() throws RecognitionException { + Exception_sectContext _localctx = new Exception_sectContext(_ctx, getState()); + enterRule(_localctx, 1588, RULE_exception_sect); + try { + setState(10627); + _errHandler.sync(this); + switch (_input.LA(1)) { + case END_P: + enterOuterAlt(_localctx, 1); + { + } + break; + case EXCEPTION: + enterOuterAlt(_localctx, 2); + { + setState(10625); + match(EXCEPTION); + setState(10626); + proc_exceptions(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Proc_exceptionsContext extends ParserRuleContext { + public List proc_exception() { + return getRuleContexts(Proc_exceptionContext.class); + } + public Proc_exceptionContext proc_exception(int i) { + return getRuleContext(Proc_exceptionContext.class,i); + } + public Proc_exceptionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_proc_exceptions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterProc_exceptions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitProc_exceptions(this); + } + } + + public final Proc_exceptionsContext proc_exceptions() throws RecognitionException { + Proc_exceptionsContext _localctx = new Proc_exceptionsContext(_ctx, getState()); + enterRule(_localctx, 1590, RULE_proc_exceptions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10630); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(10629); + proc_exception(); + } + } + setState(10632); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHEN ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Proc_exceptionContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public Proc_conditionsContext proc_conditions() { + return getRuleContext(Proc_conditionsContext.class,0); + } + public TerminalNode THEN() { return getToken(PostgreSqlParser.THEN, 0); } + public Proc_sectContext proc_sect() { + return getRuleContext(Proc_sectContext.class,0); + } + public Proc_exceptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_proc_exception; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterProc_exception(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitProc_exception(this); + } + } + + public final Proc_exceptionContext proc_exception() throws RecognitionException { + Proc_exceptionContext _localctx = new Proc_exceptionContext(_ctx, getState()); + enterRule(_localctx, 1592, RULE_proc_exception); + try { + enterOuterAlt(_localctx, 1); + { + setState(10634); + match(WHEN); + setState(10635); + proc_conditions(); + setState(10636); + match(THEN); + setState(10637); + proc_sect(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Proc_conditionsContext extends ParserRuleContext { + public List proc_condition() { + return getRuleContexts(Proc_conditionContext.class); + } + public Proc_conditionContext proc_condition(int i) { + return getRuleContext(Proc_conditionContext.class,i); + } + public List OR() { return getTokens(PostgreSqlParser.OR); } + public TerminalNode OR(int i) { + return getToken(PostgreSqlParser.OR, i); + } + public Proc_conditionsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_proc_conditions; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterProc_conditions(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitProc_conditions(this); + } + } + + public final Proc_conditionsContext proc_conditions() throws RecognitionException { + Proc_conditionsContext _localctx = new Proc_conditionsContext(_ctx, getState()); + enterRule(_localctx, 1594, RULE_proc_conditions); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10639); + proc_condition(); + setState(10644); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OR) { + { + { + setState(10640); + match(OR); + setState(10641); + proc_condition(); + } + } + setState(10646); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Proc_conditionContext extends ParserRuleContext { + public Any_identifierContext any_identifier() { + return getRuleContext(Any_identifierContext.class,0); + } + public TerminalNode SQLSTATE() { return getToken(PostgreSqlParser.SQLSTATE, 0); } + public SconstContext sconst() { + return getRuleContext(SconstContext.class,0); + } + public Proc_conditionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_proc_condition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterProc_condition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitProc_condition(this); + } + } + + public final Proc_conditionContext proc_condition() throws RecognitionException { + Proc_conditionContext _localctx = new Proc_conditionContext(_ctx, getState()); + enterRule(_localctx, 1596, RULE_proc_condition); + try { + setState(10650); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,738,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(10647); + any_identifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10648); + match(SQLSTATE); + setState(10649); + sconst(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_block_labelContext extends ParserRuleContext { + public Label_declContext label_decl() { + return getRuleContext(Label_declContext.class,0); + } + public Opt_block_labelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_block_label; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_block_label(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_block_label(this); + } + } + + public final Opt_block_labelContext opt_block_label() throws RecognitionException { + Opt_block_labelContext _localctx = new Opt_block_labelContext(_ctx, getState()); + enterRule(_localctx, 1598, RULE_opt_block_label); + try { + setState(10654); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BEGIN_P: + case DECLARE: + enterOuterAlt(_localctx, 1); + { + } + break; + case LESS_LESS: + enterOuterAlt(_localctx, 2); + { + setState(10653); + label_decl(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_loop_labelContext extends ParserRuleContext { + public Label_declContext label_decl() { + return getRuleContext(Label_declContext.class,0); + } + public Opt_loop_labelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_loop_label; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_loop_label(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_loop_label(this); + } + } + + public final Opt_loop_labelContext opt_loop_label() throws RecognitionException { + Opt_loop_labelContext _localctx = new Opt_loop_labelContext(_ctx, getState()); + enterRule(_localctx, 1600, RULE_opt_loop_label); + try { + setState(10658); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + case WHILE: + case FOREACH: + case LOOP: + enterOuterAlt(_localctx, 1); + { + } + break; + case LESS_LESS: + enterOuterAlt(_localctx, 2); + { + setState(10657); + label_decl(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_labelContext extends ParserRuleContext { + public Any_identifierContext any_identifier() { + return getRuleContext(Any_identifierContext.class,0); + } + public Opt_labelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_label; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_label(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_label(this); + } + } + + public final Opt_labelContext opt_label() throws RecognitionException { + Opt_labelContext _localctx = new Opt_labelContext(_ctx, getState()); + enterRule(_localctx, 1602, RULE_opt_label); + try { + setState(10662); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EOF: + case SEMI: + case WHEN: + enterOuterAlt(_localctx, 1); + { + } + break; + case AND: + case ARRAY: + case COLLATE: + case COLUMN: + case CONSTRAINT: + case DEFAULT: + case DO: + case FETCH: + case TABLE: + case IS: + case LEFT: + case OUTER_P: + case OVER: + case RIGHT: + case ABORT_P: + case ABSOLUTE_P: + case ACCESS: + case ACTION: + case ADD_P: + case ADMIN: + case AFTER: + case AGGREGATE: + case ALSO: + case ALTER: + case ALWAYS: + case ASSERTION: + case ASSIGNMENT: + case AT: + case ATTRIBUTE: + case BACKWARD: + case BEFORE: + case BEGIN_P: + case BY: + case CACHE: + case CALLED: + case CASCADE: + case CASCADED: + case CATALOG: + case CHAIN: + case CHARACTERISTICS: + case CHECKPOINT: + case CLASS: + case CLOSE: + case CLUSTER: + case COMMENT: + case COMMENTS: + case COMMIT: + case COMMITTED: + case CONFIGURATION: + case CONNECTION: + case CONSTRAINTS: + case CONTENT_P: + case CONTINUE_P: + case CONVERSION_P: + case COPY: + case COST: + case CSV: + case CURSOR: + case CYCLE: + case DATA_P: + case DATABASE: + case DAY_P: + case DEALLOCATE: + case DECLARE: + case DEFAULTS: + case DEFERRED: + case DEFINER: + case DELETE_P: + case DELIMITER: + case DELIMITERS: + case DICTIONARY: + case DISABLE_P: + case DISCARD: + case DOCUMENT_P: + case DOMAIN_P: + case DOUBLE_P: + case DROP: + case EACH: + case ENABLE_P: + case ENCODING: + case ENCRYPTED: + case ENUM_P: + case ESCAPE: + case EVENT: + case EXCLUDE: + case EXCLUDING: + case EXCLUSIVE: + case EXECUTE: + case EXPLAIN: + case EXTENSION: + case EXTERNAL: + case FAMILY: + case FIRST_P: + case FOLLOWING: + case FORCE: + case FORWARD: + case FUNCTION: + case FUNCTIONS: + case GLOBAL: + case GRANTED: + case HANDLER: + case HEADER_P: + case HOLD: + case HOUR_P: + case IDENTITY_P: + case IF_P: + case IMMEDIATE: + case IMMUTABLE: + case IMPLICIT_P: + case INCLUDING: + case INCREMENT: + case INDEX: + case INDEXES: + case INHERIT: + case INHERITS: + case INLINE_P: + case INSENSITIVE: + case INSERT: + case INSTEAD: + case INVOKER: + case ISOLATION: + case KEY: + case LABEL: + case LANGUAGE: + case LARGE_P: + case LAST_P: + case LEAKPROOF: + case LEVEL: + case LISTEN: + case LOAD: + case LOCAL: + case LOCATION: + case LOCK_P: + case MAPPING: + case MATCH: + case MATERIALIZED: + case MAXVALUE: + case MINUTE_P: + case MINVALUE: + case MODE: + case MONTH_P: + case MOVE: + case NAME_P: + case NAMES: + case NEXT: + case NO: + case NOTHING: + case NOTIFY: + case NOWAIT: + case NULLS_P: + case OBJECT_P: + case OF: + case OFF: + case OIDS: + case OPERATOR: + case OPTION: + case OPTIONS: + case OWNED: + case OWNER: + case PARSER: + case PARTIAL: + case PARTITION: + case PASSING: + case PASSWORD: + case PLANS: + case PRECEDING: + case PREPARE: + case PREPARED: + case PRESERVE: + case PRIOR: + case PRIVILEGES: + case PROCEDURAL: + case PROCEDURE: + case PROGRAM: + case QUOTE: + case RANGE: + case READ: + case REASSIGN: + case RECHECK: + case RECURSIVE: + case REF: + case REFRESH: + case REINDEX: + case RELATIVE_P: + case RELEASE: + case RENAME: + case REPEATABLE: + case REPLACE: + case REPLICA: + case RESET: + case RESTART: + case RESTRICT: + case RETURNS: + case REVOKE: + case ROLE: + case ROLLBACK: + case ROWS: + case RULE: + case SAVEPOINT: + case SCHEMA: + case SCROLL: + case SEARCH: + case SECOND_P: + case SECURITY: + case SEQUENCE: + case SEQUENCES: + case SERIALIZABLE: + case SERVER: + case SESSION: + case SET: + case SHARE: + case SHOW: + case SIMPLE: + case SNAPSHOT: + case STABLE: + case STANDALONE_P: + case START: + case STATEMENT: + case STATISTICS: + case STDIN: + case STDOUT: + case STORAGE: + case STRICT_P: + case STRIP_P: + case SYSID: + case SYSTEM_P: + case TABLES: + case TABLESPACE: + case TEMP: + case TEMPLATE: + case TEMPORARY: + case TEXT_P: + case TRANSACTION: + case TRIGGER: + case TRUNCATE: + case TRUSTED: + case TYPE_P: + case TYPES_P: + case UNBOUNDED: + case UNCOMMITTED: + case UNENCRYPTED: + case UNKNOWN: + case UNLISTEN: + case UNLOGGED: + case UNTIL: + case UPDATE: + case VACUUM: + case VALID: + case VALIDATE: + case VALIDATOR: + case VARYING: + case VERSION_P: + case VIEW: + case VOLATILE: + case WHITESPACE_P: + case WITHOUT: + case WORK: + case WRAPPER: + case WRITE: + case XML_P: + case YEAR_P: + case YES_P: + case ZONE: + case BETWEEN: + case BIGINT: + case BIT: + case BOOLEAN_P: + case CHAR_P: + case CHARACTER: + case COALESCE: + case DEC: + case DECIMAL_P: + case EXISTS: + case EXTRACT: + case FLOAT_P: + case GREATEST: + case INOUT: + case INT_P: + case INTEGER: + case INTERVAL: + case LEAST: + case NATIONAL: + case NCHAR: + case NONE: + case NULLIF: + case NUMERIC: + case OVERLAY: + case POSITION: + case PRECISION: + case REAL: + case ROW: + case SETOF: + case SMALLINT: + case SUBSTRING: + case TIME: + case TIMESTAMP: + case TREAT: + case TRIM: + case VALUES: + case VARCHAR: + case XMLATTRIBUTES: + case XMLCOMMENT: + case XMLAGG: + case XML_IS_WELL_FORMED: + case XML_IS_WELL_FORMED_DOCUMENT: + case XML_IS_WELL_FORMED_CONTENT: + case XPATH: + case XPATH_EXISTS: + case XMLCONCAT: + case XMLELEMENT: + case XMLEXISTS: + case XMLFOREST: + case XMLPARSE: + case XMLPI: + case XMLROOT: + case XMLSERIALIZE: + case CALL: + case CURRENT_P: + case ATTACH: + case DETACH: + case EXPRESSION: + case GENERATED: + case LOGGED: + case STORED: + case INCLUDE: + case ROUTINE: + case TRANSFORM: + case IMPORT_P: + case POLICY: + case METHOD: + case REFERENCING: + case NEW: + case OLD: + case VALUE_P: + case SUBSCRIPTION: + case PUBLICATION: + case OUT_P: + case ROUTINES: + case SCHEMAS: + case PROCEDURES: + case INPUT_P: + case SUPPORT: + case PARALLEL: + case SQL_P: + case DEPENDS: + case OVERRIDING: + case CONFLICT: + case SKIP_P: + case LOCKED: + case TIES: + case ROLLUP: + case CUBE: + case GROUPING: + case SETS: + case ORDINALITY: + case XMLTABLE: + case COLUMNS: + case XMLNAMESPACES: + case ROWTYPE: + case NORMALIZED: + case WITHIN: + case FILTER: + case GROUPS: + case OTHERS: + case NFC: + case NFD: + case NFKC: + case NFKD: + case UESCAPE: + case VIEWS: + case NORMALIZE: + case DUMP: + case PRINT_STRICT_PARAMS: + case VARIABLE_CONFLICT: + case ERROR: + case USE_VARIABLE: + case USE_COLUMN: + case ALIAS: + case CONSTANT: + case PERFORM: + case GET: + case DIAGNOSTICS: + case STACKED: + case ELSIF: + case REVERSE: + case SLICE: + case EXIT: + case RETURN: + case QUERY: + case RAISE: + case SQLSTATE: + case DEBUG: + case LOG: + case INFO: + case NOTICE: + case WARNING: + case EXCEPTION: + case ASSERT: + case OPEN: + case ABS: + case CBRT: + case CEIL: + case CEILING: + case DEGREES: + case DIV: + case EXP: + case FACTORIAL: + case FLOOR: + case GCD: + case LCM: + case LN: + case LOG10: + case MIN_SCALE: + case MOD: + case PI: + case POWER: + case RADIANS: + case ROUND: + case SCALE: + case SIGN: + case SQRT: + case TRIM_SCALE: + case TRUNC: + case WIDTH_BUCKET: + case RANDOM: + case SETSEED: + case ACOS: + case ACOSD: + case ASIN: + case ASIND: + case ATAN: + case ATAND: + case ATAN2: + case ATAN2D: + case COS: + case COSD: + case COT: + case COTD: + case SIN: + case SIND: + case TAN: + case TAND: + case SINH: + case COSH: + case TANH: + case ASINH: + case ACOSH: + case ATANH: + case BIT_LENGTH: + case CHAR_LENGTH: + case CHARACTER_LENGTH: + case LOWER: + case OCTET_LENGTH: + case UPPER: + case ASCII: + case BTRIM: + case CHR: + case CONCAT: + case CONCAT_WS: + case FORMAT: + case INITCAP: + case LENGTH: + case LPAD: + case LTRIM: + case MD5: + case PARSE_IDENT: + case PG_CLIENT_ENCODING: + case QUOTE_IDENT: + case QUOTE_LITERAL: + case QUOTE_NULLABLE: + case REGEXP_COUNT: + case REGEXP_INSTR: + case REGEXP_LIKE: + case REGEXP_MATCH: + case REGEXP_MATCHES: + case REGEXP_REPLACE: + case REGEXP_SPLIT_TO_ARRAY: + case REGEXP_SPLIT_TO_TABLE: + case REGEXP_SUBSTR: + case REPEAT: + case RPAD: + case RTRIM: + case SPLIT_PART: + case STARTS_WITH: + case STRING_TO_ARRAY: + case STRING_TO_TABLE: + case STRPOS: + case SUBSTR: + case TO_ASCII: + case TO_HEX: + case TRANSLATE: + case UNISTR: + case AGE: + case CLOCK_TIMESTAMP: + case DATE_BIN: + case DATE_PART: + case DATE_TRUNC: + case ISFINITE: + case JUSTIFY_DAYS: + case JUSTIFY_HOURS: + case JUSTIFY_INTERVAL: + case MAKE_DATE: + case MAKE_INTERVAL: + case MAKE_TIME: + case MAKE_TIMESTAMP: + case MAKE_TIMESTAMPTZ: + case NOW: + case STATEMENT_TIMESTAMP: + case TIMEOFDAY: + case TRANSACTION_TIMESTAMP: + case TO_TIMESTAMP: + case TO_CHAR: + case TO_DATE: + case TO_NUMBER: + case Identifier: + case QuotedIdentifier: + case UnicodeQuotedIdentifier: + case PLSQLIDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(10661); + any_identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_exitcondContext extends ParserRuleContext { + public TerminalNode WHEN() { return getToken(PostgreSqlParser.WHEN, 0); } + public Expr_until_semiContext expr_until_semi() { + return getRuleContext(Expr_until_semiContext.class,0); + } + public Opt_exitcondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_exitcond; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_exitcond(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_exitcond(this); + } + } + + public final Opt_exitcondContext opt_exitcond() throws RecognitionException { + Opt_exitcondContext _localctx = new Opt_exitcondContext(_ctx, getState()); + enterRule(_localctx, 1604, RULE_opt_exitcond); + try { + setState(10667); + _errHandler.sync(this); + switch (_input.LA(1)) { + case WHEN: + enterOuterAlt(_localctx, 1); + { + setState(10664); + match(WHEN); + setState(10665); + expr_until_semi(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Any_identifierContext extends ParserRuleContext { + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Plsql_unreserved_keywordContext plsql_unreserved_keyword() { + return getRuleContext(Plsql_unreserved_keywordContext.class,0); + } + public Any_identifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_any_identifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAny_identifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAny_identifier(this); + } + } + + public final Any_identifierContext any_identifier() throws RecognitionException { + Any_identifierContext _localctx = new Any_identifierContext(_ctx, getState()); + enterRule(_localctx, 1606, RULE_any_identifier); + try { + setState(10671); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,743,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(10669); + colid(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10670); + plsql_unreserved_keyword(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Plsql_unreserved_keywordContext extends ParserRuleContext { + public TerminalNode ABSOLUTE_P() { return getToken(PostgreSqlParser.ABSOLUTE_P, 0); } + public TerminalNode ALIAS() { return getToken(PostgreSqlParser.ALIAS, 0); } + public TerminalNode AND() { return getToken(PostgreSqlParser.AND, 0); } + public TerminalNode ARRAY() { return getToken(PostgreSqlParser.ARRAY, 0); } + public TerminalNode ASSERT() { return getToken(PostgreSqlParser.ASSERT, 0); } + public TerminalNode BACKWARD() { return getToken(PostgreSqlParser.BACKWARD, 0); } + public TerminalNode CALL() { return getToken(PostgreSqlParser.CALL, 0); } + public TerminalNode CHAIN() { return getToken(PostgreSqlParser.CHAIN, 0); } + public TerminalNode CLOSE() { return getToken(PostgreSqlParser.CLOSE, 0); } + public TerminalNode COLLATE() { return getToken(PostgreSqlParser.COLLATE, 0); } + public TerminalNode COLUMN() { return getToken(PostgreSqlParser.COLUMN, 0); } + public TerminalNode COMMIT() { return getToken(PostgreSqlParser.COMMIT, 0); } + public TerminalNode CONSTANT() { return getToken(PostgreSqlParser.CONSTANT, 0); } + public TerminalNode CONSTRAINT() { return getToken(PostgreSqlParser.CONSTRAINT, 0); } + public TerminalNode CONTINUE_P() { return getToken(PostgreSqlParser.CONTINUE_P, 0); } + public TerminalNode CURRENT_P() { return getToken(PostgreSqlParser.CURRENT_P, 0); } + public TerminalNode CURSOR() { return getToken(PostgreSqlParser.CURSOR, 0); } + public TerminalNode DEBUG() { return getToken(PostgreSqlParser.DEBUG, 0); } + public TerminalNode DEFAULT() { return getToken(PostgreSqlParser.DEFAULT, 0); } + public TerminalNode DIAGNOSTICS() { return getToken(PostgreSqlParser.DIAGNOSTICS, 0); } + public TerminalNode DO() { return getToken(PostgreSqlParser.DO, 0); } + public TerminalNode DUMP() { return getToken(PostgreSqlParser.DUMP, 0); } + public TerminalNode ELSIF() { return getToken(PostgreSqlParser.ELSIF, 0); } + public TerminalNode ERROR() { return getToken(PostgreSqlParser.ERROR, 0); } + public TerminalNode EXCEPTION() { return getToken(PostgreSqlParser.EXCEPTION, 0); } + public TerminalNode EXIT() { return getToken(PostgreSqlParser.EXIT, 0); } + public TerminalNode FETCH() { return getToken(PostgreSqlParser.FETCH, 0); } + public TerminalNode FIRST_P() { return getToken(PostgreSqlParser.FIRST_P, 0); } + public TerminalNode FORWARD() { return getToken(PostgreSqlParser.FORWARD, 0); } + public TerminalNode GET() { return getToken(PostgreSqlParser.GET, 0); } + public TerminalNode INFO() { return getToken(PostgreSqlParser.INFO, 0); } + public TerminalNode INSERT() { return getToken(PostgreSqlParser.INSERT, 0); } + public TerminalNode IS() { return getToken(PostgreSqlParser.IS, 0); } + public TerminalNode LAST_P() { return getToken(PostgreSqlParser.LAST_P, 0); } + public TerminalNode MOVE() { return getToken(PostgreSqlParser.MOVE, 0); } + public TerminalNode NEXT() { return getToken(PostgreSqlParser.NEXT, 0); } + public TerminalNode NO() { return getToken(PostgreSqlParser.NO, 0); } + public TerminalNode NOTICE() { return getToken(PostgreSqlParser.NOTICE, 0); } + public TerminalNode OPEN() { return getToken(PostgreSqlParser.OPEN, 0); } + public TerminalNode OPTION() { return getToken(PostgreSqlParser.OPTION, 0); } + public TerminalNode PERFORM() { return getToken(PostgreSqlParser.PERFORM, 0); } + public TerminalNode PRINT_STRICT_PARAMS() { return getToken(PostgreSqlParser.PRINT_STRICT_PARAMS, 0); } + public TerminalNode PRIOR() { return getToken(PostgreSqlParser.PRIOR, 0); } + public TerminalNode QUERY() { return getToken(PostgreSqlParser.QUERY, 0); } + public TerminalNode RAISE() { return getToken(PostgreSqlParser.RAISE, 0); } + public TerminalNode RELATIVE_P() { return getToken(PostgreSqlParser.RELATIVE_P, 0); } + public TerminalNode RESET() { return getToken(PostgreSqlParser.RESET, 0); } + public TerminalNode RETURN() { return getToken(PostgreSqlParser.RETURN, 0); } + public TerminalNode ROLLBACK() { return getToken(PostgreSqlParser.ROLLBACK, 0); } + public TerminalNode ROWTYPE() { return getToken(PostgreSqlParser.ROWTYPE, 0); } + public TerminalNode SCHEMA() { return getToken(PostgreSqlParser.SCHEMA, 0); } + public TerminalNode SCROLL() { return getToken(PostgreSqlParser.SCROLL, 0); } + public TerminalNode SET() { return getToken(PostgreSqlParser.SET, 0); } + public TerminalNode SLICE() { return getToken(PostgreSqlParser.SLICE, 0); } + public TerminalNode SQLSTATE() { return getToken(PostgreSqlParser.SQLSTATE, 0); } + public TerminalNode STACKED() { return getToken(PostgreSqlParser.STACKED, 0); } + public TerminalNode TABLE() { return getToken(PostgreSqlParser.TABLE, 0); } + public TerminalNode TYPE_P() { return getToken(PostgreSqlParser.TYPE_P, 0); } + public TerminalNode USE_COLUMN() { return getToken(PostgreSqlParser.USE_COLUMN, 0); } + public TerminalNode USE_VARIABLE() { return getToken(PostgreSqlParser.USE_VARIABLE, 0); } + public TerminalNode VARIABLE_CONFLICT() { return getToken(PostgreSqlParser.VARIABLE_CONFLICT, 0); } + public TerminalNode WARNING() { return getToken(PostgreSqlParser.WARNING, 0); } + public TerminalNode OUTER_P() { return getToken(PostgreSqlParser.OUTER_P, 0); } + public Plsql_unreserved_keywordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_plsql_unreserved_keyword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterPlsql_unreserved_keyword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitPlsql_unreserved_keyword(this); + } + } + + public final Plsql_unreserved_keywordContext plsql_unreserved_keyword() throws RecognitionException { + Plsql_unreserved_keywordContext _localctx = new Plsql_unreserved_keywordContext(_ctx, getState()); + enterRule(_localctx, 1608, RULE_plsql_unreserved_keyword); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(10673); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -8610636025129074688L) != 0) || ((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & 2310346885883232257L) != 0) || ((((_la - 159)) & ~0x3f) == 0 && ((1L << (_la - 159)) & 10133099161617425L) != 0) || ((((_la - 234)) & ~0x3f) == 0 && ((1L << (_la - 234)) & 18015499698831617L) != 0) || ((((_la - 302)) & ~0x3f) == 0 && ((1L << (_la - 302)) & 9007199322050625L) != 0) || ((((_la - 435)) & ~0x3f) == 0 && ((1L << (_la - 435)) & -144097595889811453L) != 0) || ((((_la - 499)) & ~0x3f) == 0 && ((1L << (_la - 499)) & 12516927L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Sql_expressionContext extends ParserRuleContext { + public Opt_target_listContext opt_target_list() { + return getRuleContext(Opt_target_listContext.class,0); + } + public Into_clauseContext into_clause() { + return getRuleContext(Into_clauseContext.class,0); + } + public From_clauseContext from_clause() { + return getRuleContext(From_clauseContext.class,0); + } + public Where_clauseContext where_clause() { + return getRuleContext(Where_clauseContext.class,0); + } + public Group_clauseContext group_clause() { + return getRuleContext(Group_clauseContext.class,0); + } + public Having_clauseContext having_clause() { + return getRuleContext(Having_clauseContext.class,0); + } + public Window_clauseContext window_clause() { + return getRuleContext(Window_clauseContext.class,0); + } + public Sql_expressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sql_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSql_expression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSql_expression(this); + } + } + + public final Sql_expressionContext sql_expression() throws RecognitionException { + Sql_expressionContext _localctx = new Sql_expressionContext(_ctx, getState()); + enterRule(_localctx, 1610, RULE_sql_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(10675); + opt_target_list(); + setState(10676); + into_clause(); + setState(10677); + from_clause(); + setState(10678); + where_clause(); + setState(10679); + group_clause(); + setState(10680); + having_clause(); + setState(10681); + window_clause(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Expr_until_thenContext extends ParserRuleContext { + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public Expr_until_thenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr_until_then; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExpr_until_then(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExpr_until_then(this); + } + } + + public final Expr_until_thenContext expr_until_then() throws RecognitionException { + Expr_until_thenContext _localctx = new Expr_until_thenContext(_ctx, getState()); + enterRule(_localctx, 1612, RULE_expr_until_then); + try { + enterOuterAlt(_localctx, 1); + { + setState(10683); + sql_expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Expr_until_semiContext extends ParserRuleContext { + public Sql_expressionContext sql_expression() { + return getRuleContext(Sql_expressionContext.class,0); + } + public Expr_until_semiContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr_until_semi; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExpr_until_semi(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExpr_until_semi(this); + } + } + + public final Expr_until_semiContext expr_until_semi() throws RecognitionException { + Expr_until_semiContext _localctx = new Expr_until_semiContext(_ctx, getState()); + enterRule(_localctx, 1614, RULE_expr_until_semi); + try { + enterOuterAlt(_localctx, 1); + { + setState(10685); + sql_expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Expr_until_rightbracketContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Expr_until_rightbracketContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr_until_rightbracket; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExpr_until_rightbracket(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExpr_until_rightbracket(this); + } + } + + public final Expr_until_rightbracketContext expr_until_rightbracket() throws RecognitionException { + Expr_until_rightbracketContext _localctx = new Expr_until_rightbracketContext(_ctx, getState()); + enterRule(_localctx, 1616, RULE_expr_until_rightbracket); + try { + enterOuterAlt(_localctx, 1); + { + setState(10687); + a_expr(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Expr_until_loopContext extends ParserRuleContext { + public A_exprContext a_expr() { + return getRuleContext(A_exprContext.class,0); + } + public Expr_until_loopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr_until_loop; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExpr_until_loop(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExpr_until_loop(this); + } + } + + public final Expr_until_loopContext expr_until_loop() throws RecognitionException { + Expr_until_loopContext _localctx = new Expr_until_loopContext(_ctx, getState()); + enterRule(_localctx, 1618, RULE_expr_until_loop); + try { + enterOuterAlt(_localctx, 1); + { + setState(10689); + a_expr(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Make_execsql_stmtContext extends ParserRuleContext { + public StmtContext stmt() { + return getRuleContext(StmtContext.class,0); + } + public Opt_returning_clause_intoContext opt_returning_clause_into() { + return getRuleContext(Opt_returning_clause_intoContext.class,0); + } + public Make_execsql_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_make_execsql_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterMake_execsql_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitMake_execsql_stmt(this); + } + } + + public final Make_execsql_stmtContext make_execsql_stmt() throws RecognitionException { + Make_execsql_stmtContext _localctx = new Make_execsql_stmtContext(_ctx, getState()); + enterRule(_localctx, 1620, RULE_make_execsql_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(10691); + stmt(); + setState(10692); + opt_returning_clause_into(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Opt_returning_clause_intoContext extends ParserRuleContext { + public TerminalNode INTO() { return getToken(PostgreSqlParser.INTO, 0); } + public Opt_strictContext opt_strict() { + return getRuleContext(Opt_strictContext.class,0); + } + public Into_targetContext into_target() { + return getRuleContext(Into_targetContext.class,0); + } + public Opt_returning_clause_intoContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opt_returning_clause_into; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOpt_returning_clause_into(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOpt_returning_clause_into(this); + } + } + + public final Opt_returning_clause_intoContext opt_returning_clause_into() throws RecognitionException { + Opt_returning_clause_intoContext _localctx = new Opt_returning_clause_intoContext(_ctx, getState()); + enterRule(_localctx, 1622, RULE_opt_returning_clause_into); + try { + setState(10699); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INTO: + enterOuterAlt(_localctx, 1); + { + setState(10694); + match(INTO); + setState(10695); + opt_strict(); + setState(10696); + into_target(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParameterContext extends ParserRuleContext { + public TerminalNode COLON() { return getToken(PostgreSqlParser.COLON, 0); } + public TerminalNode SPEL() { return getToken(PostgreSqlParser.SPEL, 0); } + public ColidContext colid() { + return getRuleContext(ColidContext.class,0); + } + public Reserved_keywordContext reserved_keyword() { + return getRuleContext(Reserved_keywordContext.class,0); + } + public TerminalNode QUESTION() { return getToken(PostgreSqlParser.QUESTION, 0); } + public TerminalNode Integral() { return getToken(PostgreSqlParser.Integral, 0); } + public ParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitParameter(this); + } + } + + public final ParameterContext parameter() throws RecognitionException { + ParameterContext _localctx = new ParameterContext(_ctx, getState()); + enterRule(_localctx, 1624, RULE_parameter); + try { + setState(10712); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,746,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(10701); + match(COLON); + setState(10702); + match(SPEL); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(10703); + match(COLON); + setState(10706); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,745,_ctx) ) { + case 1: + { + setState(10704); + colid(); + } + break; + case 2: + { + setState(10705); + reserved_keyword(); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(10708); + match(QUESTION); + setState(10709); + match(SPEL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(10710); + match(QUESTION); + setState(10711); + match(Integral); + } + break; } } catch (RecognitionException re) { @@ -48453,93 +99083,35 @@ public class PostgreSqlParser extends Parser { public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { switch (ruleIndex) { - case 220: - return expr_sempred((ExprContext)_localctx, predIndex); - case 224: - return bool_expr_sempred((Bool_exprContext)_localctx, predIndex); - case 248: - return from_item_sempred((From_itemContext)_localctx, predIndex); - case 252: - return predicate_sempred((PredicateContext)_localctx, predIndex); - case 264: - return identifier_sempred((IdentifierContext)_localctx, predIndex); + case 603: + return b_expr_sempred((B_exprContext)_localctx, predIndex); } return true; } - private boolean expr_sempred(ExprContext _localctx, int predIndex) { + private boolean b_expr_sempred(B_exprContext _localctx, int predIndex) { switch (predIndex) { case 0: - return precpred(_ctx, 28); - case 1: - return precpred(_ctx, 27); - case 2: - return precpred(_ctx, 26); - case 3: - return precpred(_ctx, 25); - case 4: - return precpred(_ctx, 24); - case 5: - return precpred(_ctx, 23); - case 6: - return precpred(_ctx, 22); - case 7: - return precpred(_ctx, 21); - case 8: - return precpred(_ctx, 19); - case 9: - return precpred(_ctx, 34); - case 10: - return precpred(_ctx, 29); - case 11: - return precpred(_ctx, 20); - case 12: - return precpred(_ctx, 12); - case 13: - return precpred(_ctx, 11); - case 14: - return precpred(_ctx, 9); - case 15: return precpred(_ctx, 8); - case 16: + case 1: + return precpred(_ctx, 7); + case 2: + return precpred(_ctx, 6); + case 3: return precpred(_ctx, 5); - } - return true; - } - private boolean bool_expr_sempred(Bool_exprContext _localctx, int predIndex) { - switch (predIndex) { - case 17: + case 4: + return precpred(_ctx, 4); + case 5: + return precpred(_ctx, 10); + case 6: return precpred(_ctx, 2); - case 18: + case 7: return precpred(_ctx, 1); } return true; } - private boolean from_item_sempred(From_itemContext _localctx, int predIndex) { - switch (predIndex) { - case 19: - return precpred(_ctx, 1); - } - return true; - } - private boolean predicate_sempred(PredicateContext _localctx, int predIndex) { - switch (predIndex) { - case 20: - return precpred(_ctx, 3); - case 21: - return precpred(_ctx, 2); - } - return true; - } - private boolean identifier_sempred(IdentifierContext _localctx, int predIndex) { - switch (predIndex) { - case 22: - return precpred(_ctx, 3); - } - return true; - } private static final String _serializedATNSegment0 = - "\u0004\u0001\u0345\u1651\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ + "\u0004\u0001\u02a7\u29db\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+ "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+ "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+ @@ -48617,4174 +99189,7469 @@ public class PostgreSqlParser extends Parser { "\u0107\u0002\u0108\u0007\u0108\u0002\u0109\u0007\u0109\u0002\u010a\u0007"+ "\u010a\u0002\u010b\u0007\u010b\u0002\u010c\u0007\u010c\u0002\u010d\u0007"+ "\u010d\u0002\u010e\u0007\u010e\u0002\u010f\u0007\u010f\u0002\u0110\u0007"+ - "\u0110\u0001\u0000\u0001\u0000\u0001\u0000\u0005\u0000\u0226\b\u0000\n"+ - "\u0000\f\u0000\u0229\t\u0000\u0001\u0000\u0003\u0000\u022c\b\u0000\u0001"+ - "\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003"+ - "\u0001\u0264\b\u0001\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001"+ - "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+ - "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+ - "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+ - "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+ - "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+ - "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+ - "\u0003\u0001\u0003\u0003\u0003\u0290\b\u0003\u0001\u0004\u0001\u0004\u0001"+ - "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ - "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ - "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ - "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ - "\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u02b0\b\u0004\u0001"+ - "\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+ - "\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+ - "\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+ - "\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+ - "\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u02cd\b\u0005\u0001\u0006\u0001"+ - "\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+ - "\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+ - "\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+ - "\u0006\u0001\u0006\u0003\u0006\u02e4\b\u0006\u0001\u0007\u0001\u0007\u0001"+ - "\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ - "\t\u0003\t\u02f2\b\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ - "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u0302"+ - "\b\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u030b"+ - "\b\t\u0001\t\u0001\t\u0003\t\u030f\b\t\u0001\t\u0001\t\u0001\t\u0001\t"+ - "\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ - "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ - "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ - "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u0336\b\t\u0001"+ - "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ - "\n\u0001\n\u0001\n\u0003\n\u0344\b\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ - "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0003\n\u034f\b\n\u0001\n\u0001\n\u0001"+ - "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0003\n\u0359\b\n\u0001\u000b"+ - "\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b"+ - "\u0361\b\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+ - "\u0001\u000b\u0001\u000b\u0003\u000b\u036a\b\u000b\u0001\f\u0001\f\u0001"+ - "\r\u0001\r\u0003\r\u0370\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u0376"+ - "\b\r\u0001\r\u0003\r\u0379\b\r\u0001\r\u0001\r\u0003\r\u037d\b\r\u0001"+ - "\r\u0001\r\u0003\r\u0381\b\r\u0001\r\u0001\r\u0003\r\u0385\b\r\u0001\r"+ - "\u0001\r\u0003\r\u0389\b\r\u0001\r\u0001\r\u0001\r\u0003\r\u038e\b\r\u0001"+ - "\r\u0001\r\u0001\r\u0001\r\u0003\r\u0394\b\r\u0001\r\u0001\r\u0003\r\u0398"+ - "\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03a1"+ - "\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03a9\b\r"+ - "\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03b2"+ - "\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03bb"+ - "\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003"+ - "\r\u03c5\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ - "\r\u0003\r\u03cf\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ - "\r\u0003\r\u03d8\b\r\u0001\r\u0001\r\u0001\r\u0003\r\u03dd\b\r\u0001\r"+ - "\u0001\r\u0001\r\u0001\r\u0003\r\u03e3\b\r\u0001\r\u0001\r\u0001\r\u0001"+ - "\r\u0001\r\u0001\r\u0001\r\u0003\r\u03ec\b\r\u0001\r\u0001\r\u0003\r\u03f0"+ - "\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03f7\b\r\u0001\r"+ - "\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03fe\b\r\u0001\r\u0001\r\u0001"+ - "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ - "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ - "\r\u0001\r\u0001\r\u0001\r\u0003\r\u0418\b\r\u0003\r\u041a\b\r\u0001\u000e"+ - "\u0001\u000e\u0001\u000e\u0005\u000e\u041f\b\u000e\n\u000e\f\u000e\u0422"+ - "\t\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003"+ - "\u000f\u0429\b\u000f\u0001\u000f\u0003\u000f\u042c\b\u000f\u0001\u000f"+ - "\u0001\u000f\u0003\u000f\u0430\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ - "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0439\b\u000f"+ - "\u0001\u000f\u0003\u000f\u043c\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f"+ - "\u0440\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0444\b\u000f\u0001"+ - "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ - "\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u044f\b\u000f\u0001\u000f\u0001"+ - "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ - "\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u045b\b\u000f\u0001\u000f\u0001"+ - "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0462\b\u000f\u0001"+ - "\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001"+ - "\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001"+ - "\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001"+ - "\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0003\u0011\u047b"+ - "\b\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003\u0012\u0481"+ - "\b\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003\u0012\u048c\b\u0012\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003\u0012\u049f"+ - "\b\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003\u0012\u04ab"+ - "\b\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0003\u0012\u04bb\b\u0012\u0001\u0012\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0003\u0012\u04c1\b\u0012\u0003\u0012\u04c3"+ - "\b\u0012\u0001\u0013\u0001\u0013\u0003\u0013\u04c7\b\u0013\u0001\u0013"+ + "\u0110\u0002\u0111\u0007\u0111\u0002\u0112\u0007\u0112\u0002\u0113\u0007"+ + "\u0113\u0002\u0114\u0007\u0114\u0002\u0115\u0007\u0115\u0002\u0116\u0007"+ + "\u0116\u0002\u0117\u0007\u0117\u0002\u0118\u0007\u0118\u0002\u0119\u0007"+ + "\u0119\u0002\u011a\u0007\u011a\u0002\u011b\u0007\u011b\u0002\u011c\u0007"+ + "\u011c\u0002\u011d\u0007\u011d\u0002\u011e\u0007\u011e\u0002\u011f\u0007"+ + "\u011f\u0002\u0120\u0007\u0120\u0002\u0121\u0007\u0121\u0002\u0122\u0007"+ + "\u0122\u0002\u0123\u0007\u0123\u0002\u0124\u0007\u0124\u0002\u0125\u0007"+ + "\u0125\u0002\u0126\u0007\u0126\u0002\u0127\u0007\u0127\u0002\u0128\u0007"+ + "\u0128\u0002\u0129\u0007\u0129\u0002\u012a\u0007\u012a\u0002\u012b\u0007"+ + "\u012b\u0002\u012c\u0007\u012c\u0002\u012d\u0007\u012d\u0002\u012e\u0007"+ + "\u012e\u0002\u012f\u0007\u012f\u0002\u0130\u0007\u0130\u0002\u0131\u0007"+ + "\u0131\u0002\u0132\u0007\u0132\u0002\u0133\u0007\u0133\u0002\u0134\u0007"+ + "\u0134\u0002\u0135\u0007\u0135\u0002\u0136\u0007\u0136\u0002\u0137\u0007"+ + "\u0137\u0002\u0138\u0007\u0138\u0002\u0139\u0007\u0139\u0002\u013a\u0007"+ + "\u013a\u0002\u013b\u0007\u013b\u0002\u013c\u0007\u013c\u0002\u013d\u0007"+ + "\u013d\u0002\u013e\u0007\u013e\u0002\u013f\u0007\u013f\u0002\u0140\u0007"+ + "\u0140\u0002\u0141\u0007\u0141\u0002\u0142\u0007\u0142\u0002\u0143\u0007"+ + "\u0143\u0002\u0144\u0007\u0144\u0002\u0145\u0007\u0145\u0002\u0146\u0007"+ + "\u0146\u0002\u0147\u0007\u0147\u0002\u0148\u0007\u0148\u0002\u0149\u0007"+ + "\u0149\u0002\u014a\u0007\u014a\u0002\u014b\u0007\u014b\u0002\u014c\u0007"+ + "\u014c\u0002\u014d\u0007\u014d\u0002\u014e\u0007\u014e\u0002\u014f\u0007"+ + "\u014f\u0002\u0150\u0007\u0150\u0002\u0151\u0007\u0151\u0002\u0152\u0007"+ + "\u0152\u0002\u0153\u0007\u0153\u0002\u0154\u0007\u0154\u0002\u0155\u0007"+ + "\u0155\u0002\u0156\u0007\u0156\u0002\u0157\u0007\u0157\u0002\u0158\u0007"+ + "\u0158\u0002\u0159\u0007\u0159\u0002\u015a\u0007\u015a\u0002\u015b\u0007"+ + "\u015b\u0002\u015c\u0007\u015c\u0002\u015d\u0007\u015d\u0002\u015e\u0007"+ + "\u015e\u0002\u015f\u0007\u015f\u0002\u0160\u0007\u0160\u0002\u0161\u0007"+ + "\u0161\u0002\u0162\u0007\u0162\u0002\u0163\u0007\u0163\u0002\u0164\u0007"+ + "\u0164\u0002\u0165\u0007\u0165\u0002\u0166\u0007\u0166\u0002\u0167\u0007"+ + "\u0167\u0002\u0168\u0007\u0168\u0002\u0169\u0007\u0169\u0002\u016a\u0007"+ + "\u016a\u0002\u016b\u0007\u016b\u0002\u016c\u0007\u016c\u0002\u016d\u0007"+ + "\u016d\u0002\u016e\u0007\u016e\u0002\u016f\u0007\u016f\u0002\u0170\u0007"+ + "\u0170\u0002\u0171\u0007\u0171\u0002\u0172\u0007\u0172\u0002\u0173\u0007"+ + "\u0173\u0002\u0174\u0007\u0174\u0002\u0175\u0007\u0175\u0002\u0176\u0007"+ + "\u0176\u0002\u0177\u0007\u0177\u0002\u0178\u0007\u0178\u0002\u0179\u0007"+ + "\u0179\u0002\u017a\u0007\u017a\u0002\u017b\u0007\u017b\u0002\u017c\u0007"+ + "\u017c\u0002\u017d\u0007\u017d\u0002\u017e\u0007\u017e\u0002\u017f\u0007"+ + "\u017f\u0002\u0180\u0007\u0180\u0002\u0181\u0007\u0181\u0002\u0182\u0007"+ + "\u0182\u0002\u0183\u0007\u0183\u0002\u0184\u0007\u0184\u0002\u0185\u0007"+ + "\u0185\u0002\u0186\u0007\u0186\u0002\u0187\u0007\u0187\u0002\u0188\u0007"+ + "\u0188\u0002\u0189\u0007\u0189\u0002\u018a\u0007\u018a\u0002\u018b\u0007"+ + "\u018b\u0002\u018c\u0007\u018c\u0002\u018d\u0007\u018d\u0002\u018e\u0007"+ + "\u018e\u0002\u018f\u0007\u018f\u0002\u0190\u0007\u0190\u0002\u0191\u0007"+ + "\u0191\u0002\u0192\u0007\u0192\u0002\u0193\u0007\u0193\u0002\u0194\u0007"+ + "\u0194\u0002\u0195\u0007\u0195\u0002\u0196\u0007\u0196\u0002\u0197\u0007"+ + "\u0197\u0002\u0198\u0007\u0198\u0002\u0199\u0007\u0199\u0002\u019a\u0007"+ + "\u019a\u0002\u019b\u0007\u019b\u0002\u019c\u0007\u019c\u0002\u019d\u0007"+ + "\u019d\u0002\u019e\u0007\u019e\u0002\u019f\u0007\u019f\u0002\u01a0\u0007"+ + "\u01a0\u0002\u01a1\u0007\u01a1\u0002\u01a2\u0007\u01a2\u0002\u01a3\u0007"+ + "\u01a3\u0002\u01a4\u0007\u01a4\u0002\u01a5\u0007\u01a5\u0002\u01a6\u0007"+ + "\u01a6\u0002\u01a7\u0007\u01a7\u0002\u01a8\u0007\u01a8\u0002\u01a9\u0007"+ + "\u01a9\u0002\u01aa\u0007\u01aa\u0002\u01ab\u0007\u01ab\u0002\u01ac\u0007"+ + "\u01ac\u0002\u01ad\u0007\u01ad\u0002\u01ae\u0007\u01ae\u0002\u01af\u0007"+ + "\u01af\u0002\u01b0\u0007\u01b0\u0002\u01b1\u0007\u01b1\u0002\u01b2\u0007"+ + "\u01b2\u0002\u01b3\u0007\u01b3\u0002\u01b4\u0007\u01b4\u0002\u01b5\u0007"+ + "\u01b5\u0002\u01b6\u0007\u01b6\u0002\u01b7\u0007\u01b7\u0002\u01b8\u0007"+ + "\u01b8\u0002\u01b9\u0007\u01b9\u0002\u01ba\u0007\u01ba\u0002\u01bb\u0007"+ + "\u01bb\u0002\u01bc\u0007\u01bc\u0002\u01bd\u0007\u01bd\u0002\u01be\u0007"+ + "\u01be\u0002\u01bf\u0007\u01bf\u0002\u01c0\u0007\u01c0\u0002\u01c1\u0007"+ + "\u01c1\u0002\u01c2\u0007\u01c2\u0002\u01c3\u0007\u01c3\u0002\u01c4\u0007"+ + "\u01c4\u0002\u01c5\u0007\u01c5\u0002\u01c6\u0007\u01c6\u0002\u01c7\u0007"+ + "\u01c7\u0002\u01c8\u0007\u01c8\u0002\u01c9\u0007\u01c9\u0002\u01ca\u0007"+ + "\u01ca\u0002\u01cb\u0007\u01cb\u0002\u01cc\u0007\u01cc\u0002\u01cd\u0007"+ + "\u01cd\u0002\u01ce\u0007\u01ce\u0002\u01cf\u0007\u01cf\u0002\u01d0\u0007"+ + "\u01d0\u0002\u01d1\u0007\u01d1\u0002\u01d2\u0007\u01d2\u0002\u01d3\u0007"+ + "\u01d3\u0002\u01d4\u0007\u01d4\u0002\u01d5\u0007\u01d5\u0002\u01d6\u0007"+ + "\u01d6\u0002\u01d7\u0007\u01d7\u0002\u01d8\u0007\u01d8\u0002\u01d9\u0007"+ + "\u01d9\u0002\u01da\u0007\u01da\u0002\u01db\u0007\u01db\u0002\u01dc\u0007"+ + "\u01dc\u0002\u01dd\u0007\u01dd\u0002\u01de\u0007\u01de\u0002\u01df\u0007"+ + "\u01df\u0002\u01e0\u0007\u01e0\u0002\u01e1\u0007\u01e1\u0002\u01e2\u0007"+ + "\u01e2\u0002\u01e3\u0007\u01e3\u0002\u01e4\u0007\u01e4\u0002\u01e5\u0007"+ + "\u01e5\u0002\u01e6\u0007\u01e6\u0002\u01e7\u0007\u01e7\u0002\u01e8\u0007"+ + "\u01e8\u0002\u01e9\u0007\u01e9\u0002\u01ea\u0007\u01ea\u0002\u01eb\u0007"+ + "\u01eb\u0002\u01ec\u0007\u01ec\u0002\u01ed\u0007\u01ed\u0002\u01ee\u0007"+ + "\u01ee\u0002\u01ef\u0007\u01ef\u0002\u01f0\u0007\u01f0\u0002\u01f1\u0007"+ + "\u01f1\u0002\u01f2\u0007\u01f2\u0002\u01f3\u0007\u01f3\u0002\u01f4\u0007"+ + "\u01f4\u0002\u01f5\u0007\u01f5\u0002\u01f6\u0007\u01f6\u0002\u01f7\u0007"+ + "\u01f7\u0002\u01f8\u0007\u01f8\u0002\u01f9\u0007\u01f9\u0002\u01fa\u0007"+ + "\u01fa\u0002\u01fb\u0007\u01fb\u0002\u01fc\u0007\u01fc\u0002\u01fd\u0007"+ + "\u01fd\u0002\u01fe\u0007\u01fe\u0002\u01ff\u0007\u01ff\u0002\u0200\u0007"+ + "\u0200\u0002\u0201\u0007\u0201\u0002\u0202\u0007\u0202\u0002\u0203\u0007"+ + "\u0203\u0002\u0204\u0007\u0204\u0002\u0205\u0007\u0205\u0002\u0206\u0007"+ + "\u0206\u0002\u0207\u0007\u0207\u0002\u0208\u0007\u0208\u0002\u0209\u0007"+ + "\u0209\u0002\u020a\u0007\u020a\u0002\u020b\u0007\u020b\u0002\u020c\u0007"+ + "\u020c\u0002\u020d\u0007\u020d\u0002\u020e\u0007\u020e\u0002\u020f\u0007"+ + "\u020f\u0002\u0210\u0007\u0210\u0002\u0211\u0007\u0211\u0002\u0212\u0007"+ + "\u0212\u0002\u0213\u0007\u0213\u0002\u0214\u0007\u0214\u0002\u0215\u0007"+ + "\u0215\u0002\u0216\u0007\u0216\u0002\u0217\u0007\u0217\u0002\u0218\u0007"+ + "\u0218\u0002\u0219\u0007\u0219\u0002\u021a\u0007\u021a\u0002\u021b\u0007"+ + "\u021b\u0002\u021c\u0007\u021c\u0002\u021d\u0007\u021d\u0002\u021e\u0007"+ + "\u021e\u0002\u021f\u0007\u021f\u0002\u0220\u0007\u0220\u0002\u0221\u0007"+ + "\u0221\u0002\u0222\u0007\u0222\u0002\u0223\u0007\u0223\u0002\u0224\u0007"+ + "\u0224\u0002\u0225\u0007\u0225\u0002\u0226\u0007\u0226\u0002\u0227\u0007"+ + "\u0227\u0002\u0228\u0007\u0228\u0002\u0229\u0007\u0229\u0002\u022a\u0007"+ + "\u022a\u0002\u022b\u0007\u022b\u0002\u022c\u0007\u022c\u0002\u022d\u0007"+ + "\u022d\u0002\u022e\u0007\u022e\u0002\u022f\u0007\u022f\u0002\u0230\u0007"+ + "\u0230\u0002\u0231\u0007\u0231\u0002\u0232\u0007\u0232\u0002\u0233\u0007"+ + "\u0233\u0002\u0234\u0007\u0234\u0002\u0235\u0007\u0235\u0002\u0236\u0007"+ + "\u0236\u0002\u0237\u0007\u0237\u0002\u0238\u0007\u0238\u0002\u0239\u0007"+ + "\u0239\u0002\u023a\u0007\u023a\u0002\u023b\u0007\u023b\u0002\u023c\u0007"+ + "\u023c\u0002\u023d\u0007\u023d\u0002\u023e\u0007\u023e\u0002\u023f\u0007"+ + "\u023f\u0002\u0240\u0007\u0240\u0002\u0241\u0007\u0241\u0002\u0242\u0007"+ + "\u0242\u0002\u0243\u0007\u0243\u0002\u0244\u0007\u0244\u0002\u0245\u0007"+ + "\u0245\u0002\u0246\u0007\u0246\u0002\u0247\u0007\u0247\u0002\u0248\u0007"+ + "\u0248\u0002\u0249\u0007\u0249\u0002\u024a\u0007\u024a\u0002\u024b\u0007"+ + "\u024b\u0002\u024c\u0007\u024c\u0002\u024d\u0007\u024d\u0002\u024e\u0007"+ + "\u024e\u0002\u024f\u0007\u024f\u0002\u0250\u0007\u0250\u0002\u0251\u0007"+ + "\u0251\u0002\u0252\u0007\u0252\u0002\u0253\u0007\u0253\u0002\u0254\u0007"+ + "\u0254\u0002\u0255\u0007\u0255\u0002\u0256\u0007\u0256\u0002\u0257\u0007"+ + "\u0257\u0002\u0258\u0007\u0258\u0002\u0259\u0007\u0259\u0002\u025a\u0007"+ + "\u025a\u0002\u025b\u0007\u025b\u0002\u025c\u0007\u025c\u0002\u025d\u0007"+ + "\u025d\u0002\u025e\u0007\u025e\u0002\u025f\u0007\u025f\u0002\u0260\u0007"+ + "\u0260\u0002\u0261\u0007\u0261\u0002\u0262\u0007\u0262\u0002\u0263\u0007"+ + "\u0263\u0002\u0264\u0007\u0264\u0002\u0265\u0007\u0265\u0002\u0266\u0007"+ + "\u0266\u0002\u0267\u0007\u0267\u0002\u0268\u0007\u0268\u0002\u0269\u0007"+ + "\u0269\u0002\u026a\u0007\u026a\u0002\u026b\u0007\u026b\u0002\u026c\u0007"+ + "\u026c\u0002\u026d\u0007\u026d\u0002\u026e\u0007\u026e\u0002\u026f\u0007"+ + "\u026f\u0002\u0270\u0007\u0270\u0002\u0271\u0007\u0271\u0002\u0272\u0007"+ + "\u0272\u0002\u0273\u0007\u0273\u0002\u0274\u0007\u0274\u0002\u0275\u0007"+ + "\u0275\u0002\u0276\u0007\u0276\u0002\u0277\u0007\u0277\u0002\u0278\u0007"+ + "\u0278\u0002\u0279\u0007\u0279\u0002\u027a\u0007\u027a\u0002\u027b\u0007"+ + "\u027b\u0002\u027c\u0007\u027c\u0002\u027d\u0007\u027d\u0002\u027e\u0007"+ + "\u027e\u0002\u027f\u0007\u027f\u0002\u0280\u0007\u0280\u0002\u0281\u0007"+ + "\u0281\u0002\u0282\u0007\u0282\u0002\u0283\u0007\u0283\u0002\u0284\u0007"+ + "\u0284\u0002\u0285\u0007\u0285\u0002\u0286\u0007\u0286\u0002\u0287\u0007"+ + "\u0287\u0002\u0288\u0007\u0288\u0002\u0289\u0007\u0289\u0002\u028a\u0007"+ + "\u028a\u0002\u028b\u0007\u028b\u0002\u028c\u0007\u028c\u0002\u028d\u0007"+ + "\u028d\u0002\u028e\u0007\u028e\u0002\u028f\u0007\u028f\u0002\u0290\u0007"+ + "\u0290\u0002\u0291\u0007\u0291\u0002\u0292\u0007\u0292\u0002\u0293\u0007"+ + "\u0293\u0002\u0294\u0007\u0294\u0002\u0295\u0007\u0295\u0002\u0296\u0007"+ + "\u0296\u0002\u0297\u0007\u0297\u0002\u0298\u0007\u0298\u0002\u0299\u0007"+ + "\u0299\u0002\u029a\u0007\u029a\u0002\u029b\u0007\u029b\u0002\u029c\u0007"+ + "\u029c\u0002\u029d\u0007\u029d\u0002\u029e\u0007\u029e\u0002\u029f\u0007"+ + "\u029f\u0002\u02a0\u0007\u02a0\u0002\u02a1\u0007\u02a1\u0002\u02a2\u0007"+ + "\u02a2\u0002\u02a3\u0007\u02a3\u0002\u02a4\u0007\u02a4\u0002\u02a5\u0007"+ + "\u02a5\u0002\u02a6\u0007\u02a6\u0002\u02a7\u0007\u02a7\u0002\u02a8\u0007"+ + "\u02a8\u0002\u02a9\u0007\u02a9\u0002\u02aa\u0007\u02aa\u0002\u02ab\u0007"+ + "\u02ab\u0002\u02ac\u0007\u02ac\u0002\u02ad\u0007\u02ad\u0002\u02ae\u0007"+ + "\u02ae\u0002\u02af\u0007\u02af\u0002\u02b0\u0007\u02b0\u0002\u02b1\u0007"+ + "\u02b1\u0002\u02b2\u0007\u02b2\u0002\u02b3\u0007\u02b3\u0002\u02b4\u0007"+ + "\u02b4\u0002\u02b5\u0007\u02b5\u0002\u02b6\u0007\u02b6\u0002\u02b7\u0007"+ + "\u02b7\u0002\u02b8\u0007\u02b8\u0002\u02b9\u0007\u02b9\u0002\u02ba\u0007"+ + "\u02ba\u0002\u02bb\u0007\u02bb\u0002\u02bc\u0007\u02bc\u0002\u02bd\u0007"+ + "\u02bd\u0002\u02be\u0007\u02be\u0002\u02bf\u0007\u02bf\u0002\u02c0\u0007"+ + "\u02c0\u0002\u02c1\u0007\u02c1\u0002\u02c2\u0007\u02c2\u0002\u02c3\u0007"+ + "\u02c3\u0002\u02c4\u0007\u02c4\u0002\u02c5\u0007\u02c5\u0002\u02c6\u0007"+ + "\u02c6\u0002\u02c7\u0007\u02c7\u0002\u02c8\u0007\u02c8\u0002\u02c9\u0007"+ + "\u02c9\u0002\u02ca\u0007\u02ca\u0002\u02cb\u0007\u02cb\u0002\u02cc\u0007"+ + "\u02cc\u0002\u02cd\u0007\u02cd\u0002\u02ce\u0007\u02ce\u0002\u02cf\u0007"+ + "\u02cf\u0002\u02d0\u0007\u02d0\u0002\u02d1\u0007\u02d1\u0002\u02d2\u0007"+ + "\u02d2\u0002\u02d3\u0007\u02d3\u0002\u02d4\u0007\u02d4\u0002\u02d5\u0007"+ + "\u02d5\u0002\u02d6\u0007\u02d6\u0002\u02d7\u0007\u02d7\u0002\u02d8\u0007"+ + "\u02d8\u0002\u02d9\u0007\u02d9\u0002\u02da\u0007\u02da\u0002\u02db\u0007"+ + "\u02db\u0002\u02dc\u0007\u02dc\u0002\u02dd\u0007\u02dd\u0002\u02de\u0007"+ + "\u02de\u0002\u02df\u0007\u02df\u0002\u02e0\u0007\u02e0\u0002\u02e1\u0007"+ + "\u02e1\u0002\u02e2\u0007\u02e2\u0002\u02e3\u0007\u02e3\u0002\u02e4\u0007"+ + "\u02e4\u0002\u02e5\u0007\u02e5\u0002\u02e6\u0007\u02e6\u0002\u02e7\u0007"+ + "\u02e7\u0002\u02e8\u0007\u02e8\u0002\u02e9\u0007\u02e9\u0002\u02ea\u0007"+ + "\u02ea\u0002\u02eb\u0007\u02eb\u0002\u02ec\u0007\u02ec\u0002\u02ed\u0007"+ + "\u02ed\u0002\u02ee\u0007\u02ee\u0002\u02ef\u0007\u02ef\u0002\u02f0\u0007"+ + "\u02f0\u0002\u02f1\u0007\u02f1\u0002\u02f2\u0007\u02f2\u0002\u02f3\u0007"+ + "\u02f3\u0002\u02f4\u0007\u02f4\u0002\u02f5\u0007\u02f5\u0002\u02f6\u0007"+ + "\u02f6\u0002\u02f7\u0007\u02f7\u0002\u02f8\u0007\u02f8\u0002\u02f9\u0007"+ + "\u02f9\u0002\u02fa\u0007\u02fa\u0002\u02fb\u0007\u02fb\u0002\u02fc\u0007"+ + "\u02fc\u0002\u02fd\u0007\u02fd\u0002\u02fe\u0007\u02fe\u0002\u02ff\u0007"+ + "\u02ff\u0002\u0300\u0007\u0300\u0002\u0301\u0007\u0301\u0002\u0302\u0007"+ + "\u0302\u0002\u0303\u0007\u0303\u0002\u0304\u0007\u0304\u0002\u0305\u0007"+ + "\u0305\u0002\u0306\u0007\u0306\u0002\u0307\u0007\u0307\u0002\u0308\u0007"+ + "\u0308\u0002\u0309\u0007\u0309\u0002\u030a\u0007\u030a\u0002\u030b\u0007"+ + "\u030b\u0002\u030c\u0007\u030c\u0002\u030d\u0007\u030d\u0002\u030e\u0007"+ + "\u030e\u0002\u030f\u0007\u030f\u0002\u0310\u0007\u0310\u0002\u0311\u0007"+ + "\u0311\u0002\u0312\u0007\u0312\u0002\u0313\u0007\u0313\u0002\u0314\u0007"+ + "\u0314\u0002\u0315\u0007\u0315\u0002\u0316\u0007\u0316\u0002\u0317\u0007"+ + "\u0317\u0002\u0318\u0007\u0318\u0002\u0319\u0007\u0319\u0002\u031a\u0007"+ + "\u031a\u0002\u031b\u0007\u031b\u0002\u031c\u0007\u031c\u0002\u031d\u0007"+ + "\u031d\u0002\u031e\u0007\u031e\u0002\u031f\u0007\u031f\u0002\u0320\u0007"+ + "\u0320\u0002\u0321\u0007\u0321\u0002\u0322\u0007\u0322\u0002\u0323\u0007"+ + "\u0323\u0002\u0324\u0007\u0324\u0002\u0325\u0007\u0325\u0002\u0326\u0007"+ + "\u0326\u0002\u0327\u0007\u0327\u0002\u0328\u0007\u0328\u0002\u0329\u0007"+ + "\u0329\u0002\u032a\u0007\u032a\u0002\u032b\u0007\u032b\u0002\u032c\u0007"+ + "\u032c\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+ + "\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0003\u0003\u0664\b\u0003\u0005"+ + "\u0003\u0666\b\u0003\n\u0003\f\u0003\u0669\t\u0003\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u06e8\b\u0004\u0001\u0005"+ + "\u0001\u0005\u0003\u0005\u06ec\b\u0005\u0001\u0006\u0001\u0006\u0001\u0006"+ + "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+ + "\u0001\b\u0001\b\u0003\b\u06f9\b\b\u0001\t\u0005\t\u06fc\b\t\n\t\f\t\u06ff"+ + "\t\t\u0001\n\u0005\n\u0702\b\n\n\n\f\n\u0705\t\n\u0001\u000b\u0001\u000b"+ + "\u0001\u000b\u0003\u000b\u070a\b\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+ + "\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+ + "\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0719\b\u000b"+ + "\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001"+ + "\f\u0001\f\u0003\f\u0725\b\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ + "\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+ + "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0737\b\u000f"+ + "\u0001\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u073c\b\u0010\u0001\u0010"+ + "\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0011"+ + "\u0001\u0011\u0003\u0011\u0746\b\u0011\u0001\u0011\u0001\u0011\u0001\u0012"+ + "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013"+ "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+ - "\u0001\u0013\u0003\u0013\u04d1\b\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+ - "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u04da\b\u0013"+ - "\u0003\u0013\u04dc\b\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ - "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014"+ - "\u04e7\b\u0014\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0017"+ - "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+ - "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+ - "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+ - "\u0001\u0017\u0001\u0017\u0003\u0017\u0502\b\u0017\u0001\u0017\u0001\u0017"+ - "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+ - "\u0001\u0017\u0001\u0017\u0003\u0017\u050e\b\u0017\u0001\u0018\u0001\u0018"+ - "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+ - "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+ - "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u0522\b\u0019"+ - "\u0001\u0019\u0001\u0019\u0003\u0019\u0526\b\u0019\u0001\u0019\u0001\u0019"+ - "\u0001\u0019\u0003\u0019\u052b\b\u0019\u0003\u0019\u052d\b\u0019\u0001"+ - "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003"+ - "\u001a\u0535\b\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ - "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u053f\b\u001a\u0001"+ + "\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015"+ + "\u0001\u0015\u0003\u0015\u075e\b\u0015\u0001\u0015\u0001\u0015\u0001\u0015"+ + "\u0001\u0015\u0001\u0015\u0003\u0015\u0765\b\u0015\u0001\u0015\u0001\u0015"+ + "\u0001\u0016\u0001\u0016\u0003\u0016\u076b\b\u0016\u0001\u0017\u0005\u0017"+ + "\u076e\b\u0017\n\u0017\f\u0017\u0771\t\u0017\u0001\u0018\u0001\u0018\u0001"+ + "\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u0779\b\u0018\u0001"+ + "\u0019\u0001\u0019\u0003\u0019\u077d\b\u0019\u0001\u0019\u0001\u0019\u0001"+ "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ - "\u001a\u0001\u001a\u0003\u001a\u0549\b\u001a\u0001\u001a\u0001\u001a\u0001"+ - "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ - "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ - "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ - "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u0563\b\u001a\u0001"+ - "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+ - "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+ - "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0003"+ - "\u001b\u0577\b\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+ - "\u001b\u0003\u001b\u057e\b\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ - "\u001c\u0003\u001c\u0584\b\u001c\u0001\u001c\u0004\u001c\u0587\b\u001c"+ - "\u000b\u001c\f\u001c\u0588\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ - "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ - "\u0001\u001c\u0003\u001c\u0596\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ - "\u0003\u001c\u059b\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ - "\u0001\u001c\u0003\u001c\u05a2\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ - "\u0001\u001c\u0003\u001c\u05a8\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ - "\u0003\u001c\u05ad\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ - "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c"+ - "\u05b8\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u05bd\b"+ + "\u001a\u0001\u001a\u0003\u001a\u0789\b\u001a\u0001\u001b\u0001\u001b\u0001"+ + "\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ - "\u001c\u0003\u001c\u05c5\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003"+ - "\u001c\u05ca\b\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u05ce\b\u001c"+ - "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d"+ - "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e"+ - "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+ - "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+ - "\u0003\u001e\u05e8\b\u001e\u0003\u001e\u05ea\b\u001e\u0001\u001f\u0001"+ - "\u001f\u0001\u001f\u0001\u001f\u0003\u001f\u05f0\b\u001f\u0001\u001f\u0001"+ - "\u001f\u0001 \u0003 \u05f5\b \u0001 \u0001 \u0003 \u05f9\b \u0001 \u0001"+ - " \u0003 \u05fd\b \u0001 \u0001 \u0003 \u0601\b \u0005 \u0603\b \n \f "+ - "\u0606\t \u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0003!\u060f"+ - "\b!\u0001!\u0001!\u0001!\u0001!\u0001!\u0003!\u0616\b!\u0001!\u0001!\u0001"+ - "!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+ - "!\u0001!\u0003!\u0626\b!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001"+ - "\"\u0001\"\u0001\"\u0003\"\u0630\b\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u07a8\b\u001c\u0001\u001d\u0001"+ + "\u001d\u0001\u001d\u0005\u001d\u07ad\b\u001d\n\u001d\f\u001d\u07b0\t\u001d"+ + "\u0001\u001e\u0001\u001e\u0001\u001e\u0005\u001e\u07b5\b\u001e\n\u001e"+ + "\f\u001e\u07b8\t\u001e\u0001\u001f\u0001\u001f\u0003\u001f\u07bc\b\u001f"+ + "\u0001 \u0001 \u0001 \u0001 \u0001 \u0003 \u07c3\b \u0001!\u0001!\u0001"+ + "!\u0001!\u0003!\u07c9\b!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001"+ "\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001"+ - "\"\u0003\"\u0640\b\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#"+ - "\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ - "#\u0003#\u0653\b#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ - "#\u0001#\u0001#\u0003#\u065f\b#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ - "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ - "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ - "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0003#\u0681\b#\u0001$\u0001"+ - "$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001"+ - "$\u0001$\u0001$\u0003$\u0691\b$\u0001%\u0001%\u0001&\u0001&\u0001&\u0001"+ - "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ - "&\u0001&\u0003&\u06a4\b&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ - "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0003"+ - "&\u06b6\b&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0003\'\u06f3\b\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "\'\u0001\'\u0001\'\u0003\'\u0713\b\'\u0001(\u0001(\u0001)\u0001)\u0001"+ - "*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+ - "*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0003*\u072b\b*\u0001"+ - "+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001"+ - "+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0003+\u0740"+ - "\b+\u0001,\u0001,\u0001-\u0001-\u0001.\u0001.\u0001.\u0001.\u0001.\u0001"+ - ".\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001/\u0001/\u00010\u0001"+ - "0\u00030\u0756\b0\u00010\u00010\u00010\u00010\u00010\u00030\u075d\b0\u0001"+ - "1\u00011\u00012\u00012\u00013\u00013\u00014\u00014\u00015\u00015\u0001"+ - "6\u00016\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+ - "7\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+ - "7\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+ - "7\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+ - "7\u00037\u0792\b7\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ - "8\u00018\u00019\u00019\u00019\u00019\u00019\u00039\u07a2\b9\u00019\u0003"+ - "9\u07a5\b9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ - "9\u00019\u00019\u00019\u00019\u00019\u00039\u07b5\b9\u00019\u00019\u0001"+ - "9\u00019\u00039\u07bb\b9\u00019\u00019\u00039\u07bf\b9\u00019\u00019\u0001"+ - "9\u00019\u00039\u07c5\b9\u00019\u00019\u00019\u00019\u00039\u07cb\b9\u0001"+ - "9\u00019\u00019\u00019\u00039\u07d1\b9\u00019\u00019\u00019\u00019\u0003"+ - "9\u07d7\b9\u00019\u00019\u00019\u00019\u00039\u07dd\b9\u00019\u00019\u0001"+ - "9\u00019\u00039\u07e3\b9\u00019\u00019\u00019\u00019\u00039\u07e9\b9\u0001"+ - "9\u00019\u00019\u00019\u00039\u07ef\b9\u00019\u00019\u00019\u00019\u0003"+ - "9\u07f5\b9\u00019\u00019\u00039\u07f9\b9\u00019\u00019\u00019\u00019\u0003"+ - "9\u07ff\b9\u00019\u00019\u00019\u00019\u00039\u0805\b9\u00019\u00019\u0001"+ - "9\u00019\u00039\u080b\b9\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ - "9\u00039\u0814\b9\u00019\u00039\u0817\b9\u00019\u00039\u081a\b9\u0001"+ - "9\u00019\u00019\u00039\u081f\b9\u00019\u00039\u0822\b9\u00019\u00019\u0001"+ - "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ - "9\u00019\u00039\u0832\b9\u00019\u00019\u00019\u00019\u00039\u0838\b9\u0001"+ - "9\u00019\u00039\u083c\b9\u00019\u00019\u00019\u00019\u00039\u0842\b9\u0001"+ - "9\u00019\u00019\u00019\u00039\u0848\b9\u00019\u00019\u00039\u084c\b9\u0001"+ - "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ - "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ - "9\u00039\u0863\b9\u00019\u00019\u00019\u00019\u00039\u0869\b9\u00019\u0001"+ - "9\u00039\u086d\b9\u00019\u00019\u00019\u00019\u00039\u0873\b9\u00019\u0001"+ - "9\u00019\u00019\u00039\u0879\b9\u00019\u00019\u00019\u00019\u00039\u087f"+ - "\b9\u00019\u00019\u00019\u00019\u00039\u0885\b9\u00019\u00019\u00019\u0001"+ - "9\u00039\u088b\b9\u00019\u00019\u00019\u00019\u00039\u0891\b9\u00019\u0001"+ - "9\u00019\u00019\u00039\u0897\b9\u00019\u00019\u00019\u00019\u00039\u089d"+ - "\b9\u00019\u00019\u00019\u00019\u00039\u08a3\b9\u00019\u00019\u00039\u08a7"+ - "\b9\u00019\u00019\u00019\u00019\u00039\u08ad\b9\u00019\u00019\u00019\u0001"+ - "9\u00039\u08b3\b9\u00019\u00019\u00039\u08b7\b9\u0001:\u0001:\u0001:\u0001"+ - ":\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001"+ - ":\u0003:\u08c7\b:\u0001:\u0001:\u0001:\u0001:\u0003:\u08cd\b:\u0001:\u0001"+ - ":\u0001:\u0001:\u0003:\u08d3\b:\u0001;\u0001;\u0001;\u0001;\u0001;\u0001"+ - ";\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001"+ - ";\u0001;\u0001;\u0003;\u08e7\b;\u0001<\u0001<\u0001<\u0005<\u08ec\b<\n"+ - "<\f<\u08ef\t<\u0001=\u0001=\u0001=\u0001=\u0001=\u0003=\u08f6\b=\u0001"+ - "=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0003"+ - "=\u0902\b=\u0001=\u0001=\u0001=\u0001=\u0003=\u0908\b=\u0001>\u0001>\u0003"+ - ">\u090c\b>\u0001>\u0001>\u0001>\u0001>\u0001>\u0001>\u0001>\u0001>\u0001"+ - ">\u0001?\u0001?\u0001?\u0001?\u0003?\u091b\b?\u0001?\u0001?\u0001?\u0003"+ - "?\u0920\b?\u0001?\u0001?\u0001?\u0003?\u0925\b?\u0001?\u0001?\u0001?\u0003"+ - "?\u092a\b?\u0001?\u0001?\u0001?\u0003?\u092f\b?\u0001?\u0001?\u0001?\u0003"+ - "?\u0934\b?\u0001?\u0001?\u0001?\u0003?\u0939\b?\u0001?\u0001?\u0001?\u0003"+ - "?\u093e\b?\u0001?\u0001?\u0001?\u0001?\u0003?\u0944\b?\u0001?\u0001?\u0001"+ - "?\u0003?\u0949\b?\u0001@\u0001@\u0003@\u094d\b@\u0001@\u0001@\u0001@\u0001"+ - "@\u0001@\u0001@\u0001@\u0001@\u0003@\u0957\b@\u0001A\u0001A\u0001A\u0001"+ - "A\u0003A\u095d\bA\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0005A\u0965"+ - "\bA\nA\fA\u0968\tA\u0001B\u0001B\u0001B\u0001B\u0001B\u0001B\u0005B\u0970"+ - "\bB\nB\fB\u0973\tB\u0001B\u0001B\u0001B\u0005B\u0978\bB\nB\fB\u097b\t"+ - "B\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0003C\u0985"+ - "\bC\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001"+ - "D\u0005D\u0991\bD\nD\fD\u0994\tD\u0001E\u0001E\u0001E\u0001E\u0001E\u0001"+ - "E\u0001E\u0001E\u0001E\u0005E\u099f\bE\nE\fE\u09a2\tE\u0001E\u0001E\u0001"+ - "E\u0001E\u0003E\u09a8\bE\u0001E\u0001E\u0001E\u0001E\u0001E\u0003E\u09af"+ - "\bE\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0003F\u09b7\bF\u0001F\u0001"+ - "F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0003F\u09c2\bF\u0001"+ - "F\u0001F\u0003F\u09c6\bF\u0001F\u0001F\u0001F\u0003F\u09cb\bF\u0001F\u0001"+ - "F\u0001F\u0001F\u0001F\u0001F\u0001F\u0003F\u09d4\bF\u0001G\u0001G\u0001"+ - "G\u0003G\u09d9\bG\u0001G\u0001G\u0001G\u0001H\u0001H\u0001H\u0001H\u0003"+ - "H\u09e2\bH\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001"+ - "H\u0001H\u0001H\u0001H\u0001H\u0003H\u09f1\bH\u0001H\u0001H\u0001H\u0001"+ - "H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001"+ - "H\u0001H\u0001H\u0001H\u0001H\u0001H\u0004H\u0a06\bH\u000bH\fH\u0a07\u0003"+ - "H\u0a0a\bH\u0001I\u0001I\u0003I\u0a0e\bI\u0001I\u0001I\u0003I\u0a12\b"+ - "I\u0001I\u0001I\u0001I\u0003I\u0a17\bI\u0001I\u0003I\u0a1a\bI\u0001I\u0001"+ - "I\u0001I\u0001I\u0003I\u0a20\bI\u0001I\u0001I\u0003I\u0a24\bI\u0001I\u0001"+ - "I\u0003I\u0a28\bI\u0001J\u0001J\u0001J\u0003J\u0a2d\bJ\u0001J\u0003J\u0a30"+ - "\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u0a37\bJ\u0001J\u0003J\u0a3a"+ - "\bJ\u0001J\u0003J\u0a3d\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0003"+ - "J\u0a45\bJ\u0001J\u0001J\u0003J\u0a49\bJ\u0003J\u0a4b\bJ\u0001K\u0001"+ - "K\u0001K\u0001K\u0001K\u0001K\u0003K\u0a53\bK\u0001K\u0001K\u0001K\u0001"+ - "K\u0001K\u0003K\u0a5a\bK\u0001K\u0003K\u0a5d\bK\u0001K\u0001K\u0003K\u0a61"+ - "\bK\u0001K\u0001K\u0001K\u0001K\u0003K\u0a67\bK\u0001K\u0003K\u0a6a\b"+ - "K\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001"+ - "L\u0001L\u0003L\u0a77\bL\u0001L\u0001L\u0001L\u0001L\u0003L\u0a7d\bL\u0001"+ - "L\u0001L\u0001L\u0001L\u0003L\u0a83\bL\u0001L\u0001L\u0001L\u0001L\u0003"+ - "L\u0a89\bL\u0001L\u0001L\u0001L\u0001L\u0003L\u0a8f\bL\u0001L\u0001L\u0001"+ - "L\u0001L\u0003L\u0a95\bL\u0001L\u0001L\u0003L\u0a99\bL\u0001L\u0001L\u0003"+ - "L\u0a9d\bL\u0001L\u0001L\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+ - "M\u0001M\u0001M\u0003M\u0aaa\bM\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+ - "M\u0003M\u0ab2\bM\u0001M\u0001M\u0003M\u0ab6\bM\u0001M\u0001M\u0001M\u0001"+ - "M\u0001M\u0001M\u0001M\u0003M\u0abf\bM\u0001N\u0001N\u0001N\u0001N\u0001"+ - "N\u0003N\u0ac6\bN\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0003"+ - "N\u0acf\bN\u0001N\u0001N\u0001N\u0001N\u0005N\u0ad5\bN\nN\fN\u0ad8\tN"+ - "\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001"+ - "P\u0001P\u0001P\u0001P\u0001P\u0003P\u0ae8\bP\u0001P\u0001P\u0003P\u0aec"+ - "\bP\u0001P\u0001P\u0001P\u0001P\u0001P\u0003P\u0af3\bP\u0001P\u0001P\u0001"+ - "P\u0001P\u0001P\u0001P\u0003P\u0afb\bP\u0001Q\u0001Q\u0001Q\u0001Q\u0003"+ - "Q\u0b01\bQ\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ - "Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0003"+ - "Q\u0b15\bQ\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ - "Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ - "Q\u0004Q\u0b2a\bQ\u000bQ\fQ\u0b2b\u0003Q\u0b2e\bQ\u0001R\u0001R\u0001"+ - "S\u0001S\u0001S\u0003S\u0b35\bS\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ - "S\u0001S\u0001S\u0001S\u0003S\u0b40\bS\u0001S\u0001S\u0003S\u0b44\bS\u0001"+ - "S\u0001S\u0003S\u0b48\bS\u0001T\u0001T\u0001T\u0001T\u0001T\u0003T\u0b4f"+ - "\bT\u0001T\u0003T\u0b52\bT\u0001T\u0001T\u0001T\u0001T\u0001T\u0003T\u0b59"+ - "\bT\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0003T\u0b63"+ - "\bT\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0003T\u0b6c\bT\u0001"+ - "U\u0001U\u0003U\u0b70\bU\u0001U\u0001U\u0001U\u0001U\u0003U\u0b76\bU\u0001"+ - "U\u0001U\u0001U\u0003U\u0b7b\bU\u0001U\u0003U\u0b7e\bU\u0001U\u0001U\u0001"+ - "U\u0001U\u0003U\u0b84\bU\u0001U\u0001U\u0001U\u0001U\u0003U\u0b8a\bU\u0001"+ - "U\u0001U\u0003U\u0b8e\bU\u0001U\u0003U\u0b91\bU\u0001U\u0001U\u0003U\u0b95"+ - "\bU\u0001U\u0003U\u0b98\bU\u0001U\u0003U\u0b9b\bU\u0001U\u0001U\u0001"+ - "U\u0001U\u0001U\u0001U\u0001U\u0003U\u0ba4\bU\u0003U\u0ba6\bU\u0001V\u0001"+ - "V\u0001W\u0001W\u0001X\u0001X\u0001Y\u0001Y\u0001Z\u0001Z\u0001[\u0001"+ - "[\u0001\\\u0001\\\u0001]\u0001]\u0001^\u0001^\u0001_\u0001_\u0001`\u0001"+ - "`\u0001a\u0001a\u0001b\u0001b\u0001c\u0001c\u0001d\u0001d\u0001e\u0001"+ - "e\u0001e\u0003e\u0bc9\be\u0001e\u0003e\u0bcc\be\u0001e\u0003e\u0bcf\b"+ - "e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0003e\u0bd7\be\u0001e\u0001"+ - "e\u0001e\u0001e\u0001e\u0003e\u0bde\be\u0001e\u0001e\u0001e\u0003e\u0be3"+ - "\be\u0001e\u0001e\u0003e\u0be7\be\u0001e\u0001e\u0003e\u0beb\be\u0001"+ - "f\u0001f\u0001g\u0001g\u0001h\u0003h\u0bf2\bh\u0001h\u0001h\u0001h\u0003"+ - "h\u0bf7\bh\u0001h\u0001h\u0003h\u0bfb\bh\u0001h\u0003h\u0bfe\bh\u0001"+ - "h\u0003h\u0c01\bh\u0001h\u0001h\u0003h\u0c05\bh\u0001h\u0001h\u0001h\u0001"+ - "h\u0001h\u0003h\u0c0c\bh\u0001h\u0003h\u0c0f\bh\u0001i\u0001i\u0001i\u0001"+ - "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ - "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ - "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ - "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ - "j\u0003j\u0c3d\bj\u0001k\u0001k\u0001k\u0001k\u0001k\u0003k\u0c44\bk\u0001"+ - "k\u0001k\u0003k\u0c48\bk\u0001l\u0001l\u0001l\u0001l\u0003l\u0c4e\bl\u0001"+ - "l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m\u0001m\u0003m\u0c59"+ - "\bm\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0003m\u0c61\bm\u0001n\u0001"+ - "n\u0001n\u0001n\u0003n\u0c67\bn\u0001n\u0001n\u0003n\u0c6b\bn\u0001o\u0001"+ - "o\u0001o\u0001o\u0003o\u0c71\bo\u0001o\u0001o\u0003o\u0c75\bo\u0001p\u0001"+ - "p\u0001p\u0001p\u0003p\u0c7b\bp\u0001p\u0001p\u0001q\u0001q\u0001q\u0001"+ - "q\u0003q\u0c83\bq\u0001q\u0001q\u0003q\u0c87\bq\u0001r\u0001r\u0001r\u0001"+ - "r\u0001r\u0003r\u0c8e\br\u0001r\u0001r\u0003r\u0c92\br\u0001s\u0001s\u0001"+ - "s\u0001s\u0003s\u0c98\bs\u0001s\u0001s\u0003s\u0c9c\bs\u0001t\u0001t\u0001"+ - "t\u0001t\u0001t\u0001t\u0003t\u0ca4\bt\u0001t\u0001t\u0003t\u0ca8\bt\u0001"+ - "u\u0001u\u0001u\u0001u\u0001u\u0003u\u0caf\bu\u0001u\u0001u\u0003u\u0cb3"+ - "\bu\u0001v\u0001v\u0001v\u0001v\u0003v\u0cb9\bv\u0001v\u0001v\u0003v\u0cbd"+ - "\bv\u0001w\u0001w\u0001w\u0001w\u0003w\u0cc3\bw\u0001w\u0001w\u0001x\u0001"+ - "x\u0001x\u0003x\u0cca\bx\u0001x\u0001x\u0003x\u0cce\bx\u0001x\u0001x\u0003"+ - "x\u0cd2\bx\u0001y\u0001y\u0003y\u0cd6\by\u0001y\u0001y\u0001y\u0003y\u0cdb"+ - "\by\u0001y\u0001y\u0003y\u0cdf\by\u0001z\u0001z\u0001z\u0001z\u0001z\u0003"+ - "z\u0ce6\bz\u0001z\u0001z\u0003z\u0cea\bz\u0001{\u0001{\u0001|\u0001|\u0001"+ - "|\u0001|\u0001|\u0003|\u0cf3\b|\u0001|\u0001|\u0001|\u0001|\u0003|\u0cf9"+ - "\b|\u0001}\u0001}\u0001}\u0001}\u0001}\u0003}\u0d00\b}\u0001}\u0001}\u0001"+ - "}\u0001}\u0003}\u0d06\b}\u0001~\u0001~\u0001~\u0001~\u0001~\u0003~\u0d0d"+ - "\b~\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u0d13"+ - "\b\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u0d19"+ - "\b\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0003\u0080\u0d1f"+ - "\b\u0080\u0001\u0080\u0001\u0080\u0003\u0080\u0d23\b\u0080\u0001\u0081"+ - "\u0001\u0081\u0001\u0081\u0001\u0081\u0003\u0081\u0d29\b\u0081\u0001\u0081"+ - "\u0001\u0081\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0003\u0082"+ - "\u0d31\b\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0003\u0082"+ - "\u0d37\b\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0003\u0083"+ - "\u0d3d\b\u0083\u0001\u0083\u0001\u0083\u0003\u0083\u0d41\b\u0083\u0001"+ - "\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0003\u0084\u0d47\b\u0084\u0001"+ - "\u0084\u0001\u0084\u0003\u0084\u0d4b\b\u0084\u0001\u0085\u0001\u0085\u0001"+ - "\u0085\u0001\u0085\u0003\u0085\u0d51\b\u0085\u0001\u0085\u0001\u0085\u0003"+ - "\u0085\u0d55\b\u0085\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0003"+ - "\u0086\u0d5b\b\u0086\u0001\u0086\u0001\u0086\u0001\u0087\u0001\u0087\u0001"+ - "\u0087\u0001\u0087\u0003\u0087\u0d63\b\u0087\u0001\u0087\u0001\u0087\u0003"+ - "\u0087\u0d67\b\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0003"+ - "\u0088\u0d6d\b\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u0d71\b\u0088"+ - "\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0003\u0089\u0d77\b\u0089"+ - "\u0001\u0089\u0001\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a"+ - "\u0001\u008a\u0001\u008a\u0003\u008a\u0d81\b\u008a\u0001\u008a\u0001\u008a"+ - "\u0003\u008a\u0d85\b\u008a\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b"+ - "\u0001\u008b\u0001\u008b\u0003\u008b\u0d8d\b\u008b\u0001\u008b\u0001\u008b"+ - "\u0003\u008b\u0d91\b\u008b\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c"+ - "\u0001\u008c\u0001\u008c\u0003\u008c\u0d99\b\u008c\u0001\u008c\u0001\u008c"+ - "\u0003\u008c\u0d9d\b\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d"+ - "\u0001\u008d\u0001\u008d\u0003\u008d\u0da5\b\u008d\u0001\u008d\u0001\u008d"+ - "\u0003\u008d\u0da9\b\u008d\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e"+ - "\u0003\u008e\u0daf\b\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e"+ - "\u0001\u008e\u0001\u008e\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f"+ - "\u0003\u008f\u0dbb\b\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001\u008f"+ - "\u0003\u008f\u0dc1\b\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090"+ - "\u0003\u0090\u0dc7\b\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0dcb\b"+ - "\u0090\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u0dd1"+ - "\b\u0091\u0001\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+ - "\u0092\u0001\u0092\u0003\u0092\u0dda\b\u0092\u0001\u0092\u0001\u0092\u0001"+ - "\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0003\u0092\u0de2\b\u0092\u0001"+ - "\u0092\u0001\u0092\u0001\u0092\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+ - "\u0093\u0003\u0093\u0deb\b\u0093\u0001\u0093\u0001\u0093\u0003\u0093\u0def"+ - "\b\u0093\u0001\u0094\u0001\u0094\u0001\u0094\u0003\u0094\u0df4\b\u0094"+ - "\u0001\u0095\u0001\u0095\u0003\u0095\u0df8\b\u0095\u0001\u0095\u0003\u0095"+ - "\u0dfb\b\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095"+ - "\u0005\u0095\u0e02\b\u0095\n\u0095\f\u0095\u0e05\t\u0095\u0001\u0095\u0001"+ - "\u0095\u0003\u0095\u0e09\b\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+ - "\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0003"+ - "\u0095\u0e14\b\u0095\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097\u0001"+ - "\u0098\u0001\u0098\u0001\u0099\u0003\u0099\u0e1d\b\u0099\u0001\u0099\u0001"+ - "\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0e24\b\u0099\u0001"+ - "\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0e2a\b\u0099\u0001"+ - "\u0099\u0001\u0099\u0003\u0099\u0e2e\b\u0099\u0001\u0099\u0003\u0099\u0e31"+ - "\b\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0e37"+ - "\b\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001"+ - "\u0099\u0003\u0099\u0e3f\b\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003"+ - "\u0099\u0e44\b\u0099\u0001\u0099\u0003\u0099\u0e47\b\u0099\u0001\u0099"+ - "\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+ - "\u0003\u0099\u0e50\b\u0099\u0003\u0099\u0e52\b\u0099\u0003\u0099\u0e54"+ - "\b\u0099\u0001\u0099\u0003\u0099\u0e57\b\u0099\u0001\u009a\u0001\u009a"+ - "\u0001\u009a\u0001\u009b\u0001\u009b\u0001\u009c\u0001\u009c\u0003\u009c"+ - "\u0e60\b\u009c\u0001\u009c\u0003\u009c\u0e63\b\u009c\u0001\u009c\u0001"+ - "\u009c\u0003\u009c\u0e67\b\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001"+ - "\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001"+ - "\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001"+ - "\u009c\u0001\u009c\u0003\u009c\u0e7a\b\u009c\u0001\u009c\u0003\u009c\u0e7d"+ - "\b\u009c\u0001\u009c\u0003\u009c\u0e80\b\u009c\u0001\u009d\u0001\u009d"+ - "\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d"+ - "\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d"+ - "\u0003\u009d\u0e90\b\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0003\u009d"+ - "\u0e95\b\u009d\u0003\u009d\u0e97\b\u009d\u0001\u009d\u0003\u009d\u0e9a"+ - "\b\u009d\u0003\u009d\u0e9c\b\u009d\u0001\u009d\u0001\u009d\u0001\u009e"+ - "\u0001\u009e\u0001\u009e\u0001\u009e\u0003\u009e\u0ea4\b\u009e\u0001\u009f"+ - "\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0003\u009f"+ - "\u0eac\b\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f"+ - "\u0001\u009f\u0003\u009f\u0eb4\b\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0"+ - "\u0001\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1"+ - "\u0001\u00a1\u0003\u00a1\u0ec0\b\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1"+ - "\u0001\u00a1\u0003\u00a1\u0ec6\b\u00a1\u0005\u00a1\u0ec8\b\u00a1\n\u00a1"+ - "\f\u00a1\u0ecb\t\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1"+ - "\u0003\u00a1\u0ed1\b\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3"+ - "\u0001\u00a3\u0001\u00a3\u0003\u00a3\u0ed9\b\u00a3\u0001\u00a3\u0001\u00a3"+ - "\u0001\u00a3\u0001\u00a4\u0001\u00a4\u0003\u00a4\u0ee0\b\u00a4\u0001\u00a4"+ - "\u0001\u00a4\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u0ee7\b\u00a5"+ - "\u0001\u00a6\u0001\u00a6\u0001\u00a7\u0001\u00a7\u0003\u00a7\u0eed\b\u00a7"+ - "\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a9\u0001\u00a9"+ - "\u0003\u00a9\u0ef5\b\u00a9\u0001\u00a9\u0001\u00a9\u0003\u00a9\u0ef9\b"+ - "\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0003\u00ab\u0f04\b\u00ab\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0003\u00ab\u0f29"+ - "\b\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ab\u0003\u00ab\u0f3d\b\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001"+ - "\u00ac\u0003\u00ac\u0f43\b\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003"+ - "\u00ac\u0f48\b\u00ac\u0001\u00ac\u0001\u00ac\u0003\u00ac\u0f4c\b\u00ac"+ - "\u0001\u00ac\u0001\u00ac\u0003\u00ac\u0f50\b\u00ac\u0001\u00ac\u0004\u00ac"+ - "\u0f53\b\u00ac\u000b\u00ac\f\u00ac\u0f54\u0001\u00ac\u0001\u00ac\u0004"+ - "\u00ac\u0f59\b\u00ac\u000b\u00ac\f\u00ac\u0f5a\u0001\u00ac\u0001\u00ac"+ - "\u0003\u00ac\u0f5f\b\u00ac\u0001\u00ac\u0003\u00ac\u0f62\b\u00ac\u0001"+ - "\u00ac\u0003\u00ac\u0f65\b\u00ac\u0001\u00ac\u0003\u00ac\u0f68\b\u00ac"+ - "\u0001\u00ac\u0003\u00ac\u0f6b\b\u00ac\u0001\u00ac\u0003\u00ac\u0f6e\b"+ - "\u00ac\u0001\u00ac\u0003\u00ac\u0f71\b\u00ac\u0001\u00ac\u0003\u00ac\u0f74"+ - "\b\u00ac\u0001\u00ac\u0003\u00ac\u0f77\b\u00ac\u0001\u00ac\u0003\u00ac"+ - "\u0f7a\b\u00ac\u0001\u00ac\u0003\u00ac\u0f7d\b\u00ac\u0001\u00ad\u0003"+ - "\u00ad\u0f80\b\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0003"+ - "\u00ad\u0f86\b\u00ad\u0001\u00ad\u0003\u00ad\u0f89\b\u00ad\u0001\u00ad"+ - "\u0001\u00ad\u0003\u00ad\u0f8d\b\u00ad\u0001\u00ad\u0001\u00ad\u0003\u00ad"+ - "\u0f91\b\u00ad\u0001\u00ad\u0001\u00ad\u0003\u00ad\u0f95\b\u00ad\u0001"+ - "\u00ad\u0004\u00ad\u0f98\b\u00ad\u000b\u00ad\f\u00ad\u0f99\u0001\u00ad"+ - "\u0001\u00ad\u0004\u00ad\u0f9e\b\u00ad\u000b\u00ad\f\u00ad\u0f9f\u0001"+ - "\u00ad\u0001\u00ad\u0003\u00ad\u0fa4\b\u00ad\u0001\u00ad\u0003\u00ad\u0fa7"+ - "\b\u00ad\u0001\u00ad\u0003\u00ad\u0faa\b\u00ad\u0001\u00ad\u0003\u00ad"+ - "\u0fad\b\u00ad\u0001\u00ad\u0003\u00ad\u0fb0\b\u00ad\u0001\u00ad\u0003"+ - "\u00ad\u0fb3\b\u00ad\u0001\u00ad\u0003\u00ad\u0fb6\b\u00ad\u0001\u00ad"+ - "\u0003\u00ad\u0fb9\b\u00ad\u0001\u00ad\u0003\u00ad\u0fbc\b\u00ad\u0001"+ - "\u00ad\u0003\u00ad\u0fbf\b\u00ad\u0001\u00ad\u0003\u00ad\u0fc2\b\u00ad"+ - "\u0001\u00ae\u0001\u00ae\u0003\u00ae\u0fc6\b\u00ae\u0001\u00ae\u0001\u00ae"+ - "\u0001\u00ae\u0005\u00ae\u0fcb\b\u00ae\n\u00ae\f\u00ae\u0fce\t\u00ae\u0001"+ - "\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0003\u00af\u0fd5"+ - "\b\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001"+ - "\u00af\u0001\u00af\u0003\u00af\u0fde\b\u00af\u0001\u00af\u0001\u00af\u0001"+ - "\u00b0\u0001\u00b0\u0003\u00b0\u0fe4\b\u00b0\u0001\u00b0\u0001\u00b0\u0001"+ - "\u00b0\u0001\u00b0\u0003\u00b0\u0fea\b\u00b0\u0001\u00b0\u0001\u00b0\u0003"+ - "\u00b0\u0fee\b\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001"+ - "\u00b0\u0003\u00b0\u0ff5\b\u00b0\u0003\u00b0\u0ff7\b\u00b0\u0001\u00b1"+ - "\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u0ffd\b\u00b1\u0001\u00b1"+ - "\u0001\u00b1\u0001\u00b2\u0001\u00b2\u0003\u00b2\u1003\b\u00b2\u0001\u00b2"+ - "\u0001\u00b2\u0001\u00b2\u0003\u00b2\u1008\b\u00b2\u0001\u00b2\u0001\u00b2"+ - "\u0003\u00b2\u100c\b\u00b2\u0001\u00b3\u0001\u00b3\u0001\u00b4\u0001\u00b4"+ - "\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4"+ - "\u0001\u00b4\u0003\u00b4\u1019\b\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4"+ - "\u0001\u00b4\u0001\u00b4\u0003\u00b4\u1020\b\u00b4\u0001\u00b4\u0003\u00b4"+ - "\u1023\b\u00b4\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0005\u00b5\u1028\b"+ - "\u00b5\n\u00b5\f\u00b5\u102b\t\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6"+ - "\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6"+ - "\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0003\u00b6\u103a\b\u00b6"+ - "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0003\u00b7"+ - "\u1041\b\u00b7\u0001\u00b8\u0001\u00b8\u0003\u00b8\u1045\b\u00b8\u0001"+ - "\u00b8\u0003\u00b8\u1048\b\u00b8\u0001\u00b8\u0001\u00b8\u0003\u00b8\u104c"+ - "\b\u00b8\u0001\u00b8\u0001\u00b8\u0003\u00b8\u1050\b\u00b8\u0001\u00b8"+ - "\u0003\u00b8\u1053\b\u00b8\u0001\u00b8\u0001\u00b8\u0003\u00b8\u1057\b"+ - "\u00b8\u0001\u00b8\u0003\u00b8\u105a\b\u00b8\u0001\u00b9\u0001\u00b9\u0001"+ - "\u00b9\u0003\u00b9\u105f\b\u00b9\u0001\u00ba\u0003\u00ba\u1062\b\u00ba"+ - "\u0001\u00ba\u0001\u00ba\u0003\u00ba\u1066\b\u00ba\u0001\u00ba\u0001\u00ba"+ - "\u0003\u00ba\u106a\b\u00ba\u0001\u00ba\u0003\u00ba\u106d\b\u00ba\u0001"+ - "\u00ba\u0003\u00ba\u1070\b\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0003"+ - "\u00ba\u1075\b\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001"+ - "\u00ba\u0003\u00ba\u107c\b\u00ba\u0001\u00ba\u0003\u00ba\u107f\b\u00ba"+ - "\u0001\u00bb\u0001\u00bb\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0005\u00bc"+ - "\u1086\b\u00bc\n\u00bc\f\u00bc\u1089\t\u00bc\u0001\u00bd\u0001\u00bd\u0001"+ - "\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u1090\b\u00bd\u0001\u00bd\u0001"+ - "\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u1097\b\u00bd\u0001"+ - "\u00bd\u0001\u00bd\u0003\u00bd\u109b\b\u00bd\u0001\u00bd\u0003\u00bd\u109e"+ - "\b\u00bd\u0001\u00bd\u0003\u00bd\u10a1\b\u00bd\u0001\u00bd\u0003\u00bd"+ - "\u10a4\b\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u10a8\b\u00bd\u0001"+ - "\u00bd\u0003\u00bd\u10ab\b\u00bd\u0001\u00bd\u0003\u00bd\u10ae\b\u00bd"+ + "\"\u0003\"\u07da\b\"\u0001#\u0001#\u0001#\u0003#\u07df\b#\u0001$\u0001"+ + "$\u0003$\u07e3\b$\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001"+ + "&\u0001&\u0001&\u0001&\u0003&\u07f0\b&\u0001\'\u0001\'\u0003\'\u07f4\b"+ + "\'\u0001(\u0001(\u0001(\u0003(\u07f9\b(\u0001)\u0001)\u0001)\u0003)\u07fe"+ + "\b)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+ + "*\u0003*\u080a\b*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001,\u0001,\u0003"+ + ",\u0813\b,\u0001-\u0001-\u0001.\u0001.\u0001/\u0001/\u0001/\u00010\u0001"+ + "0\u00010\u00010\u00030\u0820\b0\u00010\u00010\u00010\u00030\u0825\b0\u0001"+ + "0\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00030\u0830"+ + "\b0\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u0003"+ + "0\u083b\b0\u00010\u00010\u00010\u00030\u0840\b0\u00010\u00010\u00010\u0001"+ + "0\u00010\u00010\u00010\u00010\u00010\u00030\u084b\b0\u00010\u00010\u0001"+ + "0\u00010\u00010\u00010\u00010\u00010\u00010\u00030\u0856\b0\u00010\u0001"+ + "0\u00010\u00010\u00010\u00010\u00010\u00030\u085f\b0\u00010\u00010\u0001"+ + "0\u00010\u00010\u00010\u00010\u00010\u00030\u0869\b0\u00010\u00010\u0001"+ + "0\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u0001"+ + "0\u00030\u0878\b0\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u0001"+ + "0\u00010\u00010\u00030\u0884\b0\u00010\u00010\u00010\u00030\u0889\b0\u0001"+ + "1\u00011\u00011\u00051\u088e\b1\n1\f1\u0891\t1\u00012\u00012\u00012\u0001"+ + "2\u00012\u00012\u00012\u00012\u00032\u089b\b2\u00013\u00013\u00013\u0001"+ + "3\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00034\u099d\b4\u00015\u00015\u00015\u00015\u00015\u0003"+ + "5\u09a4\b5\u00016\u00016\u00016\u00036\u09a9\b6\u00017\u00017\u00017\u0003"+ + "7\u09ae\b7\u00018\u00018\u00018\u00038\u09b3\b8\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00039\u09bb\b9\u0001:\u0001:\u0001:\u0001:\u0001;\u0001"+ + ";\u0001;\u0003;\u09c4\b;\u0001<\u0001<\u0001<\u0005<\u09c9\b<\n<\f<\u09cc"+ + "\t<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0003=\u09d5\b=\u0003"+ + "=\u09d7\b=\u0001>\u0004>\u09da\b>\u000b>\f>\u09db\u0001?\u0001?\u0001"+ + "?\u0001?\u0003?\u09e2\b?\u0001?\u0001?\u0001?\u0001?\u0003?\u09e8\b?\u0003"+ + "?\u09ea\b?\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001"+ + "@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001"+ + "@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0003@\u0a06\b@\u0001"+ + "A\u0001A\u0001A\u0001B\u0001B\u0001B\u0005B\u0a0e\bB\nB\fB\u0a11\tB\u0001"+ + "C\u0001C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0005D\u0a1b\bD\nD"+ + "\fD\u0a1e\tD\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001"+ + "E\u0003E\u0a29\bE\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001"+ + "E\u0001E\u0001E\u0001E\u0001E\u0003E\u0a37\bE\u0001F\u0001F\u0001F\u0003"+ + "F\u0a3c\bF\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001"+ + "G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001"+ + "G\u0001G\u0001G\u0001G\u0003G\u0a54\bG\u0001H\u0001H\u0001I\u0001I\u0003"+ + "I\u0a5a\bI\u0001J\u0001J\u0001J\u0003J\u0a5f\bJ\u0001K\u0001K\u0001K\u0001"+ + "K\u0001K\u0003K\u0a66\bK\u0001L\u0005L\u0a69\bL\nL\fL\u0a6c\tL\u0001M"+ + "\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+ + "M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+ + "M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+ + "M\u0001M\u0001M\u0001M\u0001M\u0003M\u0a91\bM\u0001N\u0001N\u0003N\u0a95"+ + "\bN\u0001O\u0001O\u0001O\u0001O\u0001O\u0003O\u0a9c\bO\u0001P\u0001P\u0003"+ + "P\u0aa0\bP\u0001Q\u0001Q\u0001Q\u0005Q\u0aa5\bQ\nQ\fQ\u0aa8\tQ\u0001R"+ + "\u0001R\u0001R\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0003S\u0ab5\bS\u0001T\u0001T\u0001T\u0005T\u0aba\bT\nT\fT\u0abd\tT"+ + "\u0001U\u0001U\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0003V\u0ac7"+ + "\bV\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001"+ + "V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001"+ + "V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001"+ + "V\u0001V\u0003V\u0ae8\bV\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+ + "W\u0001W\u0003W\u0af2\bW\u0001X\u0001X\u0003X\u0af6\bX\u0001Y\u0001Y\u0001"+ + "Y\u0001Y\u0001Y\u0003Y\u0afd\bY\u0001Z\u0001Z\u0001Z\u0005Z\u0b02\bZ\n"+ + "Z\fZ\u0b05\tZ\u0001[\u0001[\u0001[\u0005[\u0b0a\b[\n[\f[\u0b0d\t[\u0001"+ + "\\\u0001\\\u0001\\\u0003\\\u0b12\b\\\u0001]\u0001]\u0003]\u0b16\b]\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001_\u0001_\u0001_\u0003_\u0b20\b_\u0001"+ + "_\u0001_\u0001`\u0005`\u0b25\b`\n`\f`\u0b28\t`\u0001a\u0001a\u0001a\u0001"+ + "a\u0001a\u0001a\u0001a\u0001a\u0003a\u0b32\ba\u0001b\u0001b\u0001b\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0003b\u0b52\bb\u0001b\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0003b\u0b5a\bb\u0001c\u0001c\u0001c\u0003"+ + "c\u0b5f\bc\u0001d\u0001d\u0001d\u0001d\u0001d\u0003d\u0b66\bd\u0001e\u0001"+ + "e\u0001e\u0001e\u0001f\u0001f\u0005f\u0b6e\bf\nf\ff\u0b71\tf\u0001g\u0001"+ + "g\u0001h\u0001h\u0001h\u0001h\u0001h\u0003h\u0b7a\bh\u0001i\u0001i\u0001"+ + "i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+ + "i\u0001i\u0001i\u0001i\u0001i\u0001i\u0003i\u0b8e\bi\u0001i\u0001i\u0001"+ + "i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+ + "i\u0003i\u0b9d\bi\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+ + "i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+ + "i\u0001i\u0001i\u0001i\u0001i\u0001i\u0003i\u0bb6\bi\u0001j\u0001j\u0001"+ + "j\u0003j\u0bbb\bj\u0001k\u0001k\u0001k\u0001k\u0001k\u0003k\u0bc2\bk\u0001"+ + "l\u0001l\u0001l\u0005l\u0bc7\bl\nl\fl\u0bca\tl\u0001m\u0001m\u0001n\u0001"+ + "n\u0001n\u0001n\u0001n\u0001n\u0003n\u0bd4\bn\u0001o\u0001o\u0001o\u0003"+ + "o\u0bd9\bo\u0001p\u0001p\u0001p\u0005p\u0bde\bp\np\fp\u0be1\tp\u0001q"+ + "\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0003q\u0beb\bq\u0001"+ + "r\u0001r\u0001r\u0001r\u0001r\u0001r\u0003r\u0bf3\br\u0001s\u0001s\u0001"+ + "s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0003s\u0bfe\bs\u0001t\u0001"+ + "t\u0001t\u0001t\u0001u\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001"+ + "v\u0001v\u0001v\u0003v\u0c0e\bv\u0001w\u0001w\u0001w\u0001w\u0001w\u0001"+ + "w\u0003w\u0c16\bw\u0001x\u0001x\u0003x\u0c1a\bx\u0001y\u0001y\u0001y\u0001"+ + "y\u0001y\u0001y\u0001y\u0001z\u0001z\u0001z\u0005z\u0c26\bz\nz\fz\u0c29"+ + "\tz\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001"+ + "{\u0001{\u0001{\u0001{\u0001{\u0003{\u0c39\b{\u0001|\u0001|\u0001|\u0003"+ + "|\u0c3e\b|\u0001}\u0001}\u0001}\u0001}\u0001}\u0003}\u0c45\b}\u0001~\u0001"+ + "~\u0001~\u0001~\u0001~\u0001~\u0001~\u0003~\u0c4e\b~\u0001~\u0003~\u0c51"+ + "\b~\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u0c56\b\u007f\u0001"+ + "\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0003\u0080\u0c5d"+ + "\b\u0080\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0082\u0001"+ + "\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0003\u0082\u0c68\b\u0082\u0001"+ + "\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001"+ + "\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0003\u0083\u0c75"+ + "\b\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001"+ + "\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0003"+ + "\u0084\u0c82\b\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001"+ + "\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001"+ + "\u0085\u0001\u0085\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0003"+ + "\u0086\u0c94\b\u0086\u0001\u0086\u0003\u0086\u0c97\b\u0086\u0001\u0087"+ + "\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087"+ + "\u0003\u0087\u0ca0\b\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087"+ + "\u0001\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088"+ + "\u0001\u0088\u0001\u0089\u0001\u0089\u0003\u0089\u0caf\b\u0089\u0001\u008a"+ + "\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a"+ + "\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b"+ + "\u0003\u008b\u0cbe\b\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008c"+ + "\u0001\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u0cc7\b\u008c\u0001\u008c"+ + "\u0001\u008c\u0001\u008c\u0001\u008d\u0001\u008d\u0003\u008d\u0cce\b\u008d"+ + "\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0003\u008e"+ + "\u0cd5\b\u008e\u0001\u008f\u0004\u008f\u0cd8\b\u008f\u000b\u008f\f\u008f"+ + "\u0cd9\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+ + "\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+ + "\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+ + "\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+ + "\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0cf8"+ + "\b\u0090\u0003\u0090\u0cfa\b\u0090\u0001\u0091\u0001\u0091\u0003\u0091"+ + "\u0cfe\b\u0091\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092"+ + "\u0001\u0092\u0003\u0092\u0d06\b\u0092\u0001\u0093\u0001\u0093\u0001\u0093"+ + "\u0005\u0093\u0d0b\b\u0093\n\u0093\f\u0093\u0d0e\t\u0093\u0001\u0094\u0001"+ + "\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001"+ + "\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0003\u0094\u0d1b\b\u0094\u0001"+ + "\u0095\u0001\u0095\u0003\u0095\u0d1f\b\u0095\u0001\u0096\u0001\u0096\u0003"+ + "\u0096\u0d23\b\u0096\u0001\u0097\u0001\u0097\u0001\u0097\u0003\u0097\u0d28"+ + "\b\u0097\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0d2e"+ + "\b\u0098\u0001\u0099\u0001\u0099\u0003\u0099\u0d32\b\u0099\u0001\u009a"+ + "\u0001\u009a\u0003\u009a\u0d36\b\u009a\u0001\u009b\u0001\u009b\u0001\u009b"+ + "\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009c"+ + "\u0001\u009c\u0001\u009c\u0003\u009c\u0d43\b\u009c\u0001\u009d\u0001\u009d"+ + "\u0001\u009d\u0001\u009d\u0003\u009d\u0d49\b\u009d\u0001\u009d\u0001\u009d"+ + "\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0003\u009e"+ + "\u0d52\b\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009f"+ + "\u0005\u009f\u0d59\b\u009f\n\u009f\f\u009f\u0d5c\t\u009f\u0001\u00a0\u0001"+ + "\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0003"+ + "\u00a0\u0d65\b\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+ + "\u00a1\u0001\u00a1\u0001\u00a2\u0005\u00a2\u0d6e\b\u00a2\n\u00a2\f\u00a2"+ + "\u0d71\t\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+ + "\u0003\u00a4\u0dde\b\u00a4\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+ + "\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a6\u0001\u00a6"+ + "\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0001\u00a6"+ + "\u0003\u00a6\u0df0\b\u00a6\u0001\u00a7\u0004\u00a7\u0df3\b\u00a7\u000b"+ + "\u00a7\f\u00a7\u0df4\u0001\u00a8\u0001\u00a8\u0003\u00a8\u0df9\b\u00a8"+ + "\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9"+ + "\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9"+ + "\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0003\u00a9\u0e0a\b\u00a9\u0001\u00aa"+ + "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0003\u00aa"+ + "\u0e12\b\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0005\u00ab\u0e17\b"+ + "\u00ab\n\u00ab\f\u00ab\u0e1a\t\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac"+ + "\u0001\u00ac\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0005\u00ad"+ + "\u0e24\b\u00ad\n\u00ad\f\u00ad\u0e27\t\u00ad\u0001\u00ae\u0001\u00ae\u0001"+ + "\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0003\u00ae\u0e30"+ + "\b\u00ae\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00b0\u0001\u00b0\u0001"+ + "\u00b1\u0001\u00b1\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001"+ + "\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001"+ + "\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001"+ + "\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001"+ + "\u00b2\u0001\u00b2\u0001\u00b2\u0003\u00b2\u0e52\b\u00b2\u0001\u00b3\u0001"+ + "\u00b3\u0001\u00b3\u0003\u00b3\u0e57\b\u00b3\u0001\u00b4\u0001\u00b4\u0001"+ + "\u00b4\u0003\u00b4\u0e5c\b\u00b4\u0001\u00b5\u0001\u00b5\u0003\u00b5\u0e60"+ + "\b\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001"+ + "\u00b6\u0003\u00b6\u0e68\b\u00b6\u0003\u00b6\u0e6a\b\u00b6\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001\u00b7"+ + "\u0001\u00b7\u0003\u00b7\u0ea4\b\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8"+ + "\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8"+ + "\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9\u0001\u00b9"+ + "\u0003\u00b9\u0eb5\b\u00b9\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba"+ + "\u0001\u00ba\u0001\u00ba\u0003\u00ba\u0ebd\b\u00ba\u0001\u00bb\u0001\u00bb"+ + "\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb"+ + "\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb"+ + "\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb"+ + "\u0001\u00bb\u0003\u00bb\u0ed4\b\u00bb\u0001\u00bc\u0001\u00bc\u0003\u00bc"+ + "\u0ed8\b\u00bc\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+ "\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+ - "\u0003\u00bd\u10b6\b\u00bd\u0003\u00bd\u10b8\b\u00bd\u0003\u00bd\u10ba"+ - "\b\u00bd\u0001\u00be\u0003\u00be\u10bd\b\u00be\u0001\u00be\u0001\u00be"+ - "\u0001\u00be\u0004\u00be\u10c2\b\u00be\u000b\u00be\f\u00be\u10c3\u0001"+ - "\u00be\u0001\u00be\u0004\u00be\u10c8\b\u00be\u000b\u00be\f\u00be\u10c9"+ - "\u0001\u00be\u0001\u00be\u0003\u00be\u10ce\b\u00be\u0001\u00be\u0003\u00be"+ - "\u10d1\b\u00be\u0001\u00be\u0003\u00be\u10d4\b\u00be\u0001\u00be\u0003"+ - "\u00be\u10d7\b\u00be\u0001\u00be\u0003\u00be\u10da\b\u00be\u0001\u00be"+ - "\u0003\u00be\u10dd\b\u00be\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+ - "\u0003\u00bf\u10e3\b\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u10e7\b"+ - "\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001"+ - "\u00c0\u0005\u00c0\u10ef\b\u00c0\n\u00c0\f\u00c0\u10f2\t\u00c0\u0001\u00c1"+ - "\u0001\u00c1\u0001\u00c1\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2"+ - "\u0001\u00c2\u0005\u00c2\u10fc\b\u00c2\n\u00c2\f\u00c2\u10ff\t\u00c2\u0001"+ - "\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001"+ - "\u00c3\u0001\u00c3\u0003\u00c3\u1109\b\u00c3\u0001\u00c3\u0001\u00c3\u0001"+ - "\u00c3\u0003\u00c3\u110e\b\u00c3\u0005\u00c3\u1110\b\u00c3\n\u00c3\f\u00c3"+ - "\u1113\t\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3"+ - "\u0003\u00c3\u111a\b\u00c3\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4"+ - "\u0005\u00c4\u1120\b\u00c4\n\u00c4\f\u00c4\u1123\t\u00c4\u0001\u00c4\u0001"+ - "\u00c4\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0005\u00c5\u112b"+ - "\b\u00c5\n\u00c5\f\u00c5\u112e\t\u00c5\u0001\u00c6\u0001\u00c6\u0003\u00c6"+ - "\u1132\b\u00c6\u0001\u00c6\u0003\u00c6\u1135\b\u00c6\u0001\u00c6\u0003"+ - "\u00c6\u1138\b\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0003\u00c6\u113d"+ - "\b\u00c6\u0001\u00c6\u0003\u00c6\u1140\b\u00c6\u0001\u00c6\u0003\u00c6"+ - "\u1143\b\u00c6\u0005\u00c6\u1145\b\u00c6\n\u00c6\f\u00c6\u1148\t\u00c6"+ - "\u0001\u00c7\u0001\u00c7\u0003\u00c7\u114c\b\u00c7\u0001\u00c7\u0001\u00c7"+ - "\u0003\u00c7\u1150\b\u00c7\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8"+ - "\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8"+ - "\u0001\u00c8\u0001\u00c8\u0003\u00c8\u115e\b\u00c8\u0001\u00c9\u0001\u00c9"+ - "\u0001\u00ca\u0001\u00ca\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb"+ - "\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0003\u00cb\u116c\b\u00cb"+ - "\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0005\u00cc\u1171\b\u00cc\n\u00cc"+ - "\f\u00cc\u1174\t\u00cc\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd"+ - "\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00cf\u0001\u00cf\u0003\u00cf"+ - "\u117f\b\u00cf\u0001\u00cf\u0003\u00cf\u1182\b\u00cf\u0001\u00cf\u0003"+ - "\u00cf\u1185\b\u00cf\u0001\u00cf\u0003\u00cf\u1188\b\u00cf\u0001\u00cf"+ - "\u0001\u00cf\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0"+ - "\u0005\u00d0\u1191\b\u00d0\n\u00d0\f\u00d0\u1194\t\u00d0\u0001\u00d1\u0001"+ - "\u00d1\u0001\u00d1\u0003\u00d1\u1199\b\u00d1\u0001\u00d2\u0001\u00d2\u0003"+ - "\u00d2\u119d\b\u00d2\u0001\u00d2\u0005\u00d2\u11a0\b\u00d2\n\u00d2\f\u00d2"+ - "\u11a3\t\u00d2\u0001\u00d2\u0001\u00d2\u0003\u00d2\u11a7\b\u00d2\u0001"+ - "\u00d2\u0005\u00d2\u11aa\b\u00d2\n\u00d2\f\u00d2\u11ad\t\u00d2\u0001\u00d2"+ - "\u0003\u00d2\u11b0\b\u00d2\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3"+ - "\u0001\u00d3\u0005\u00d3\u11b7\b\u00d3\n\u00d3\f\u00d3\u11ba\t\u00d3\u0001"+ - "\u00d4\u0001\u00d4\u0003\u00d4\u11be\b\u00d4\u0001\u00d4\u0001\u00d4\u0001"+ - "\u00d4\u0001\u00d4\u0003\u00d4\u11c4\b\u00d4\u0001\u00d4\u0001\u00d4\u0001"+ - "\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0005\u00d4\u11cc\b\u00d4\n"+ - "\u00d4\f\u00d4\u11cf\t\u00d4\u0003\u00d4\u11d1\b\u00d4\u0001\u00d5\u0001"+ - "\u00d5\u0001\u00d5\u0001\u00d5\u0003\u00d5\u11d7\b\u00d5\u0001\u00d6\u0001"+ - "\u00d6\u0001\u00d6\u0003\u00d6\u11dc\b\u00d6\u0001\u00d7\u0001\u00d7\u0001"+ - "\u00d7\u0003\u00d7\u11e1\b\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001"+ - "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ - "\u00d8\u0001\u00d8\u0003\u00d8\u11ee\b\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ - "\u00d8\u0001\u00d8\u0005\u00d8\u11f4\b\u00d8\n\u00d8\f\u00d8\u11f7\t\u00d8"+ - "\u0003\u00d8\u11f9\b\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0005\u00d8"+ - "\u11fe\b\u00d8\n\u00d8\f\u00d8\u1201\t\u00d8\u0001\u00d9\u0001\u00d9\u0001"+ - "\u00d9\u0005\u00d9\u1206\b\u00d9\n\u00d9\f\u00d9\u1209\t\u00d9\u0001\u00da"+ - "\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da"+ - "\u0003\u00da\u1212\b\u00da\u0003\u00da\u1214\b\u00da\u0001\u00db\u0001"+ - "\u00db\u0001\u00db\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0004"+ - "\u00dc\u1229\b\u00dc\u000b\u00dc\f\u00dc\u122a\u0001\u00dc\u0001\u00dc"+ - "\u0001\u00dc\u0001\u00dc\u0004\u00dc\u1231\b\u00dc\u000b\u00dc\f\u00dc"+ - "\u1232\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u124b"+ - "\b\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u1267\b\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u1279\b\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0003\u00dc\u127e\b\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0003\u00dc\u1289\b\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u1292\b\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u12a4\b\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u12a9\b\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0003\u00dc\u12ad\b\u00dc\u0001\u00dc\u0004\u00dc\u12b0\b\u00dc"+ - "\u000b\u00dc\f\u00dc\u12b1\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0004\u00dc"+ - "\u12b7\b\u00dc\u000b\u00dc\f\u00dc\u12b8\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0003\u00dc\u12c6\b\u00dc\u0001\u00dc\u0001"+ - "\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0005\u00dc\u12ce"+ - "\b\u00dc\n\u00dc\f\u00dc\u12d1\t\u00dc\u0001\u00dd\u0001\u00dd\u0001\u00dd"+ + "\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+ + "\u0001\u00bd\u0003\u00bd\u0eec\b\u00bd\u0001\u00be\u0001\u00be\u0001\u00be"+ + "\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00be"+ + "\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+ + "\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00c0"+ + "\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+ + "\u0001\u00c0\u0001\u00c0\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1"+ + "\u0001\u00c1\u0001\u00c1\u0003\u00c1\u0f11\b\u00c1\u0001\u00c2\u0001\u00c2"+ + "\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0003\u00c2"+ + "\u0f1a\b\u00c2\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003\u00c3\u0f1f\b"+ + "\u00c3\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0003\u00c4\u0f24\b\u00c4\u0001"+ + "\u00c5\u0001\u00c5\u0001\u00c5\u0003\u00c5\u0f29\b\u00c5\u0001\u00c6\u0001"+ + "\u00c6\u0001\u00c6\u0003\u00c6\u0f2e\b\u00c6\u0001\u00c7\u0001\u00c7\u0001"+ + "\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001"+ + "\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c9\u0001\u00c9\u0001\u00ca\u0001"+ + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001"+ + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001"+ + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001"+ + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001"+ + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001"+ + "\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001"+ + "\u00ca\u0003\u00ca\u0f63\b\u00ca\u0001\u00cb\u0001\u00cb\u0001\u00cb\u0001"+ + "\u00cb\u0003\u00cb\u0f69\b\u00cb\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0005"+ + "\u00cc\u0f6e\b\u00cc\n\u00cc\f\u00cc\u0f71\t\u00cc\u0001\u00cd\u0001\u00cd"+ + "\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0003\u00cd"+ + "\u0f7a\b\u00cd\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0003\u00ce\u0f7f\b"+ + "\u00ce\u0001\u00cf\u0004\u00cf\u0f82\b\u00cf\u000b\u00cf\f\u00cf\u0f83"+ + "\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d1"+ + "\u0001\u00d1\u0001\u00d2\u0001\u00d2\u0001\u00d3\u0001\u00d3\u0001\u00d4"+ + "\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0003\u00d4\u0f96\b\u00d4"+ + "\u0001\u00d5\u0001\u00d5\u0003\u00d5\u0f9a\b\u00d5\u0001\u00d6\u0001\u00d6"+ + "\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7"+ + "\u0003\u00d7\u0fa4\b\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d9\u0001\u00d9"+ + "\u0003\u00d9\u0faa\b\u00d9\u0001\u00d9\u0001\u00d9\u0005\u00d9\u0fae\b"+ + "\u00d9\n\u00d9\f\u00d9\u0fb1\t\u00d9\u0001\u00da\u0001\u00da\u0001\u00da"+ + "\u0001\u00da\u0003\u00da\u0fb7\b\u00da\u0001\u00db\u0001\u00db\u0001\u00db"+ + "\u0003\u00db\u0fbc\b\u00db\u0001\u00dc\u0005\u00dc\u0fbf\b\u00dc\n\u00dc"+ + "\f\u00dc\u0fc2\t\u00dc\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd"+ "\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd"+ - "\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0003\u00dd\u12df\b\u00dd\u0003\u00dd"+ - "\u12e1\b\u00dd\u0001\u00de\u0001\u00de\u0003\u00de\u12e5\b\u00de\u0001"+ - "\u00df\u0001\u00df\u0003\u00df\u12e9\b\u00df\u0001\u00e0\u0001\u00e0\u0001"+ - "\u00e0\u0001\u00e0\u0001\u00e0\u0003\u00e0\u12f0\b\u00e0\u0001\u00e0\u0001"+ - "\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0005\u00e0\u12f8"+ - "\b\u00e0\n\u00e0\f\u00e0\u12fb\t\u00e0\u0001\u00e1\u0001\u00e1\u0001\u00e1"+ - "\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0004\u00e1\u1304\b\u00e1"+ - "\u000b\u00e1\f\u00e1\u1305\u0001\u00e1\u0001\u00e1\u0003\u00e1\u130a\b"+ - "\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001"+ - "\u00e1\u0001\u00e1\u0001\u00e1\u0004\u00e1\u1314\b\u00e1\u000b\u00e1\f"+ - "\u00e1\u1315\u0001\u00e1\u0001\u00e1\u0003\u00e1\u131a\b\u00e1\u0001\u00e1"+ - "\u0001\u00e1\u0003\u00e1\u131e\b\u00e1\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ - "\u0001\u00e2\u0005\u00e2\u1324\b\u00e2\n\u00e2\f\u00e2\u1327\t\u00e2\u0001"+ - "\u00e2\u0001\u00e2\u0001\u00e3\u0003\u00e3\u132c\b\u00e3\u0001\u00e3\u0001"+ - "\u00e3\u0001\u00e3\u0005\u00e3\u1331\b\u00e3\n\u00e3\f\u00e3\u1334\t\u00e3"+ - "\u0001\u00e3\u0003\u00e3\u1337\b\u00e3\u0001\u00e4\u0003\u00e4\u133a\b"+ - "\u00e4\u0001\u00e4\u0003\u00e4\u133d\b\u00e4\u0001\u00e4\u0003\u00e4\u1340"+ - "\b\u00e4\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0005\u00e5\u1345\b\u00e5"+ - "\n\u00e5\f\u00e5\u1348\t\u00e5\u0001\u00e6\u0001\u00e6\u0001\u00e6\u0001"+ - "\u00e6\u0001\u00e6\u0003\u00e6\u134f\b\u00e6\u0001\u00e7\u0001\u00e7\u0001"+ - "\u00e7\u0005\u00e7\u1354\b\u00e7\n\u00e7\f\u00e7\u1357\t\u00e7\u0001\u00e8"+ - "\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8"+ - "\u0001\u00e8\u0003\u00e8\u1361\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8"+ - "\u0001\u00e8\u0003\u00e8\u1367\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8"+ - "\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8"+ - "\u1371\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8"+ - "\u1377\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8"+ - "\u137d\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8"+ - "\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8\u1388\b\u00e8"+ - "\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8"+ - "\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8"+ - "\u0003\u00e8\u1396\b\u00e8\u0001\u00e8\u0003\u00e8\u1399\b\u00e8\u0001"+ - "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ - "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ - "\u00e8\u0003\u00e8\u13a8\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ - "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ - "\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ - "\u00e8\u0003\u00e8\u13ba\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003"+ - "\u00e8\u13bf\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003"+ - "\u00e8\u13c5\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8\u13ca"+ - "\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8\u13d0"+ - "\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8\u13d6"+ - "\b\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0001"+ - "\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8\u13e0\b\u00e8\u0001\u00e8\u0001"+ - "\u00e8\u0001\u00e8\u0001\u00e8\u0003\u00e8\u13e6\b\u00e8\u0001\u00e8\u0003"+ - "\u00e8\u13e9\b\u00e8\u0001\u00e9\u0001\u00e9\u0001\u00ea\u0001\u00ea\u0001"+ - "\u00ea\u0001\u00ea\u0003\u00ea\u13f1\b\u00ea\u0001\u00eb\u0001\u00eb\u0001"+ - "\u00eb\u0003\u00eb\u13f6\b\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0005"+ - "\u00eb\u13fb\b\u00eb\n\u00eb\f\u00eb\u13fe\t\u00eb\u0001\u00eb\u0003\u00eb"+ - "\u1401\b\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb"+ - "\u0001\u00eb\u0001\u00eb\u0003\u00eb\u140a\b\u00eb\u0001\u00eb\u0001\u00eb"+ - "\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb"+ - "\u0001\u00eb\u0001\u00eb\u0003\u00eb\u1416\b\u00eb\u0001\u00eb\u0001\u00eb"+ - "\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0005\u00eb\u141d\b\u00eb\n\u00eb"+ - "\f\u00eb\u1420\t\u00eb\u0003\u00eb\u1422\b\u00eb\u0001\u00eb\u0001\u00eb"+ - "\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb"+ - "\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0003\u00eb\u1430\b\u00eb"+ - "\u0003\u00eb\u1432\b\u00eb\u0001\u00ec\u0001\u00ec\u0003\u00ec\u1436\b"+ - "\u00ec\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0005\u00ed\u143b\b\u00ed\n"+ - "\u00ed\f\u00ed\u143e\t\u00ed\u0001\u00ee\u0001\u00ee\u0001\u00ee\u0005"+ - "\u00ee\u1443\b\u00ee\n\u00ee\f\u00ee\u1446\t\u00ee\u0001\u00ef\u0001\u00ef"+ - "\u0001\u00ef\u0003\u00ef\u144b\b\u00ef\u0001\u00f0\u0001\u00f0\u0001\u00f0"+ - "\u0005\u00f0\u1450\b\u00f0\n\u00f0\f\u00f0\u1453\t\u00f0\u0001\u00f1\u0001"+ - "\u00f1\u0001\u00f2\u0001\u00f2\u0003\u00f2\u1459\b\u00f2\u0001\u00f2\u0001"+ - "\u00f2\u0003\u00f2\u145d\b\u00f2\u0001\u00f2\u0005\u00f2\u1460\b\u00f2"+ - "\n\u00f2\f\u00f2\u1463\t\u00f2\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0005"+ - "\u00f3\u1468\b\u00f3\n\u00f3\f\u00f3\u146b\t\u00f3\u0001\u00f4\u0001\u00f4"+ - "\u0003\u00f4\u146f\b\u00f4\u0001\u00f5\u0001\u00f5\u0001\u00f6\u0001\u00f6"+ - "\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6"+ - "\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0005\u00f6\u147e\b\u00f6\n\u00f6"+ - "\f\u00f6\u1481\t\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0003\u00f6"+ - "\u1486\b\u00f6\u0003\u00f6\u1488\b\u00f6\u0001\u00f6\u0001\u00f6\u0001"+ - "\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001"+ - "\u00f6\u0003\u00f6\u1493\b\u00f6\u0001\u00f6\u0001\u00f6\u0003\u00f6\u1497"+ - "\b\u00f6\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f7\u0005"+ - "\u00f7\u149e\b\u00f7\n\u00f7\f\u00f7\u14a1\t\u00f7\u0003\u00f7\u14a3\b"+ - "\u00f7\u0001\u00f7\u0001\u00f7\u0001\u00f8\u0001\u00f8\u0003\u00f8\u14a9"+ - "\b\u00f8\u0001\u00f8\u0001\u00f8\u0003\u00f8\u14ad\b\u00f8\u0001\u00f8"+ - "\u0003\u00f8\u14b0\b\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8"+ - "\u0001\u00f8\u0001\u00f8\u0005\u00f8\u14b8\b\u00f8\n\u00f8\f\u00f8\u14bb"+ - "\t\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001"+ - "\u00f8\u0003\u00f8\u14c3\b\u00f8\u0003\u00f8\u14c5\b\u00f8\u0001\u00f8"+ - "\u0003\u00f8\u14c8\b\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8"+ - "\u0003\u00f8\u14ce\b\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8"+ - "\u0001\u00f8\u0005\u00f8\u14d5\b\u00f8\n\u00f8\f\u00f8\u14d8\t\u00f8\u0001"+ - "\u00f8\u0001\u00f8\u0003\u00f8\u14dc\b\u00f8\u0001\u00f8\u0003\u00f8\u14df"+ - "\b\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0003\u00f8\u14e4\b\u00f8"+ - "\u0001\u00f8\u0003\u00f8\u14e7\b\u00f8\u0001\u00f8\u0003\u00f8\u14ea\b"+ - "\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001"+ - "\u00f8\u0005\u00f8\u14f2\b\u00f8\n\u00f8\f\u00f8\u14f5\t\u00f8\u0001\u00f8"+ - "\u0001\u00f8\u0001\u00f8\u0003\u00f8\u14fa\b\u00f8\u0001\u00f8\u0001\u00f8"+ - "\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8"+ - "\u0001\u00f8\u0001\u00f8\u0005\u00f8\u1506\b\u00f8\n\u00f8\f\u00f8\u1509"+ - "\t\u00f8\u0001\u00f8\u0001\u00f8\u0003\u00f8\u150d\b\u00f8\u0001\u00f8"+ - "\u0001\u00f8\u0003\u00f8\u1511\b\u00f8\u0001\u00f8\u0001\u00f8\u0003\u00f8"+ - "\u1515\b\u00f8\u0001\u00f8\u0001\u00f8\u0003\u00f8\u1519\b\u00f8\u0001"+ - "\u00f8\u0001\u00f8\u0003\u00f8\u151d\b\u00f8\u0001\u00f8\u0003\u00f8\u1520"+ - "\b\u00f8\u0005\u00f8\u1522\b\u00f8\n\u00f8\f\u00f8\u1525\t\u00f8\u0001"+ - "\u00f9\u0003\u00f9\u1528\b\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001"+ - "\u00f9\u0005\u00f9\u152e\b\u00f9\n\u00f9\f\u00f9\u1531\t\u00f9\u0003\u00f9"+ - "\u1533\b\u00f9\u0001\u00f9\u0003\u00f9\u1536\b\u00f9\u0001\u00f9\u0001"+ - "\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0003\u00f9\u153d\b\u00f9\u0001"+ - "\u00fa\u0003\u00fa\u1540\b\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0003"+ - "\u00fa\u1545\b\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0003\u00fa\u154a"+ - "\b\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0003\u00fa\u154f\b\u00fa"+ - "\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0003\u00fa\u1554\b\u00fa\u0001\u00fb"+ + "\u0001\u00dd\u0003\u00dd\u0fcf\b\u00dd\u0001\u00de\u0001\u00de\u0001\u00de"+ + "\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de"+ + "\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de"+ + "\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de"+ + "\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0003\u00de"+ + "\u0feb\b\u00de\u0001\u00df\u0001\u00df\u0001\u00df\u0005\u00df\u0ff0\b"+ + "\u00df\n\u00df\f\u00df\u0ff3\t\u00df\u0001\u00e0\u0001\u00e0\u0001\u00e0"+ + "\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e1\u0001\u00e1\u0001\u00e1"+ + "\u0005\u00e1\u0ffe\b\u00e1\n\u00e1\f\u00e1\u1001\t\u00e1\u0001\u00e2\u0001"+ + "\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e3\u0001"+ + "\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0003\u00e3\u100f"+ + "\b\u00e3\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001"+ + "\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0003\u00e5\u1084\b\u00e5\u0001\u00e6\u0001\u00e6\u0001"+ + "\u00e6\u0001\u00e6\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0005\u00e7\u108d"+ + "\b\u00e7\n\u00e7\f\u00e7\u1090\t\u00e7\u0001\u00e8\u0001\u00e8\u0001\u00e8"+ + "\u0003\u00e8\u1095\b\u00e8\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00e9"+ + "\u0001\u00e9\u0001\u00e9\u0003\u00e9\u109d\b\u00e9\u0001\u00ea\u0001\u00ea"+ + "\u0001\u00ea\u0001\u00ea\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0005\u00eb"+ + "\u10a6\b\u00eb\n\u00eb\f\u00eb\u10a9\t\u00eb\u0001\u00ec\u0001\u00ec\u0001"+ + "\u00ec\u0001\u00ec\u0001\u00ed\u0001\u00ed\u0003\u00ed\u10b1\b\u00ed\u0001"+ + "\u00ee\u0001\u00ee\u0001\u00ee\u0005\u00ee\u10b6\b\u00ee\n\u00ee\f\u00ee"+ + "\u10b9\t\u00ee\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef"+ + "\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef"+ + "\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef"+ + "\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef"+ + "\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef"+ + "\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef\u0001\u00ef"+ + "\u0001\u00ef\u0001\u00ef\u0003\u00ef\u10e0\b\u00ef\u0001\u00f0\u0001\u00f0"+ + "\u0001\u00f0\u0001\u00f0\u0003\u00f0\u10e6\b\u00f0\u0001\u00f1\u0001\u00f1"+ + "\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1"+ + "\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0001\u00f1"+ + "\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0005\u00f2\u10f9\b\u00f2\n\u00f2"+ + "\f\u00f2\u10fc\t\u00f2\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+ + "\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+ + "\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+ + "\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3"+ + "\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0003\u00f3\u1117\b\u00f3\u0001\u00f4"+ + "\u0001\u00f4\u0003\u00f4\u111b\b\u00f4\u0001\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0003\u00f5\u1120\b\u00f5\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6"+ + "\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0003\u00f6\u1129\b\u00f6\u0001\u00f7"+ + "\u0001\u00f7\u0003\u00f7\u112d\b\u00f7\u0001\u00f8\u0001\u00f8\u0001\u00f8"+ + "\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f9\u0001\u00f9"+ + "\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9"+ + "\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9"+ + "\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0001\u00f9\u0003\u00f9\u1148\b\u00f9"+ + "\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0005\u00fa\u114d\b\u00fa\n\u00fa"+ + "\f\u00fa\u1150\t\u00fa\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb"+ "\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb\u0001\u00fb"+ - "\u0005\u00fb\u155d\b\u00fb\n\u00fb\f\u00fb\u1560\t\u00fb\u0001\u00fb\u0001"+ - "\u00fb\u0003\u00fb\u1564\b\u00fb\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001"+ - "\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001"+ - "\u00fc\u0001\u00fc\u0001\u00fc\u0003\u00fc\u1572\b\u00fc\u0001\u00fc\u0001"+ - "\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0005\u00fc\u157a"+ - "\b\u00fc\n\u00fc\f\u00fc\u157d\t\u00fc\u0001\u00fd\u0001\u00fd\u0003\u00fd"+ - "\u1581\b\u00fd\u0001\u00fd\u0003\u00fd\u1584\b\u00fd\u0001\u00fd\u0001"+ - "\u00fd\u0003\u00fd\u1588\b\u00fd\u0001\u00fd\u0003\u00fd\u158b\b\u00fd"+ - "\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0003\u00fd"+ - "\u1592\b\u00fd\u0001\u00fd\u0003\u00fd\u1595\b\u00fd\u0001\u00fd\u0001"+ - "\u00fd\u0003\u00fd\u1599\b\u00fd\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001"+ - "\u00ff\u0004\u00ff\u159f\b\u00ff\u000b\u00ff\f\u00ff\u15a0\u0001\u0100"+ - "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0003\u0100\u15a8\b\u0100"+ - "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0003\u0100\u15ae\b\u0100"+ - "\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0003\u0101"+ - "\u15b5\b\u0101\u0001\u0101\u0003\u0101\u15b8\b\u0101\u0001\u0101\u0003"+ - "\u0101\u15bb\b\u0101\u0001\u0101\u0001\u0101\u0003\u0101\u15bf\b\u0101"+ - "\u0001\u0102\u0001\u0102\u0003\u0102\u15c3\b\u0102\u0001\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0003\u0102\u15cb\b\u0102"+ - "\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0102\u0001\u0102\u0003\u0102\u15dc\b\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0003\u0102\u15e9\b\u0102"+ - "\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0102\u0003\u0102\u15f3\b\u0102\u0001\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0102\u0001\u0102\u0003\u0102\u15fa\b\u0102\u0001\u0102"+ - "\u0001\u0102\u0001\u0102\u0003\u0102\u15ff\b\u0102\u0001\u0102\u0001\u0102"+ - "\u0001\u0102\u0003\u0102\u1604\b\u0102\u0003\u0102\u1606\b\u0102\u0001"+ - "\u0102\u0003\u0102\u1609\b\u0102\u0001\u0102\u0003\u0102\u160c\b\u0102"+ - "\u0001\u0102\u0001\u0102\u0003\u0102\u1610\b\u0102\u0001\u0103\u0001\u0103"+ - "\u0001\u0103\u0001\u0103\u0003\u0103\u1616\b\u0103\u0001\u0104\u0001\u0104"+ - "\u0001\u0104\u0005\u0104\u161b\b\u0104\n\u0104\f\u0104\u161e\t\u0104\u0001"+ - "\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001"+ - "\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0001\u0105\u0003\u0105\u162b"+ - "\b\u0105\u0001\u0106\u0001\u0106\u0001\u0107\u0001\u0107\u0001\u0108\u0001"+ - "\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0003\u0108\u1637"+ - "\b\u0108\u0001\u0108\u0001\u0108\u0001\u0108\u0005\u0108\u163c\b\u0108"+ - "\n\u0108\f\u0108\u163f\t\u0108\u0001\u0109\u0001\u0109\u0001\u010a\u0001"+ - "\u010a\u0001\u010b\u0001\u010b\u0001\u010c\u0001\u010c\u0001\u010d\u0001"+ - "\u010d\u0001\u010e\u0001\u010e\u0001\u010f\u0001\u010f\u0001\u0110\u0001"+ - "\u0110\u0001\u0110\u0000\u0005\u01b8\u01c0\u01f0\u01f8\u0210\u0111\u0000"+ - "\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c"+ - "\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ - "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c"+ - "\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4"+ - "\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc"+ - "\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4"+ - "\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc"+ - "\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114"+ - "\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c"+ - "\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144"+ - "\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c"+ - "\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174"+ - "\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c"+ - "\u018e\u0190\u0192\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4"+ - "\u01a6\u01a8\u01aa\u01ac\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc"+ - "\u01be\u01c0\u01c2\u01c4\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4"+ - "\u01d6\u01d8\u01da\u01dc\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec"+ - "\u01ee\u01f0\u01f2\u01f4\u01f6\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204"+ - "\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c"+ - "\u021e\u0220\u00002\u0002\u0000\u00bc\u00bc\u0207\u0207\u0002\u0000<<"+ - "\u01da\u01da\u0002\u0000\u0014\u0014\u01d7\u01d7\u0004\u0000\u00d6\u00d6"+ - "\u00d8\u00d8\u0143\u0143\u01a7\u01a7\u0003\u0000\u000b\u000b\u00bc\u00bc"+ - "\u0207\u0207\u0002\u0000\u0247\u0247\u0319\u0319\u0002\u0000\u0109\u0109"+ - "\u027e\u027e\u0001\u0000\u02b0\u02b2\u0002\u0000\u00c5\u00c5\u0262\u0262"+ - "\u0002\u0000\u0172\u0172\u030a\u030a\u0005\u0000\u0010\u0010\u00a3\u00a3"+ - "\u0116\u0116\u01fe\u01fe\u026b\u026b\u0004\u0000\u00a3\u00a3\u0116\u0116"+ - "\u01fe\u01fe\u026b\u026b\u0002\u0000\u0012\u0012\u0119\u0119\u0002\u0000"+ - "\u023b\u023b\u023d\u023d\u0002\u0000==\u013a\u013a\u0005\u0000\u0010\u0010"+ - "\u01a8\u01a8\u0202\u0202\u023b\u023b\u023d\u023d\u0002\u0000\u0235\u0235"+ - "\u026e\u026e\u0002\u0000\u00ec\u00ec\u0109\u0109\u0005\u0000\u0092\u0092"+ - "\u010c\u010c\u01f3\u01f3\u0235\u0235\u0237\u0237\u0002\u0000\u024c\u024c"+ - "\u028b\u028b\u0003\u0000\u023b\u023b\u023d\u023d\u0267\u0267\u0002\u0000"+ - "\u013a\u013a\u0205\u0205\u0002\u0000\u009f\u009f\u0105\u0105\u0002\u0000"+ - "tt\u01d9\u01d9\u0005\u0000\u0016\u0016\u00b4\u00b4\u00eb\u00eb\u00ed\u00ed"+ - "\u0280\u0280\u0002\u0000\u0083\u0083\u01e7\u01e7\u0005\u0000\u0016\u0016"+ - "55zz\u0246\u0246\u0280\u0280\u0004\u0000\u028d\u028d\u02e0\u02e0\u02f1"+ - "\u02f1\u02f9\u02f9\u0002\u0000\u01bc\u01bc\u01ef\u01ef\u0003\u0000\u00cb"+ - "\u00cb\u011c\u011c\u0263\u0263\u0002\u0000\u0010\u0010\u00b8\u00b8\u0002"+ - "\u0000\u00df\u00df\u012d\u012d\u0002\u0000\u01ec\u01ec\u01ef\u01ef\u0002"+ - "\u0000\u00df\u00df\u0166\u0166\u0001\u0000\u02fd\u02fd\u0004\u0000\u0314"+ - "\u0314\u0316\u0316\u032f\u032f\u0335\u0335\u0002\u0000\u0339\u0339\u033c"+ - "\u033c\u0002\u0000\u0010\u0010\u016d\u016d\u0002\u0000\u0318\u0318\u0333"+ - "\u0334\u0003\u0000\u02ff\u02ff\u0330\u0330\u033b\u033b\u0002\u0000\u032f"+ - "\u032f\u0335\u0335\f\u0000\u0017\u0017\u016d\u016d\u0187\u0187\u030f\u0313"+ - "\u031a\u031a\u031d\u0325\u0328\u0329\u032b\u032e\u0331\u0332\u0336\u0338"+ - "\u033a\u033a\u033c\u0343\u0005\u0000\u0317\u0317\u0319\u0319\u031b\u031c"+ - "\u0326\u0327\u032a\u032a\u0004\u0000\u0109\u0109\u0113\u0113\u018c\u018c"+ - "\u027e\u027e\u0002\u0000\u0288\u0288\u028a\u028a\u0002\u0000\u0306\u0307"+ - "\u030a\u030b\u0001\u0000\u02bf\u02c4\u0002\u0000\u001c\u001c\u00ab\u00ab"+ - "\b\u0000~~\u00bc\u00bc\u00ec\u00ec\u00fa\u00fa\u0136\u0136\u0188\u0188"+ - "\u01fe\u01fe\u0263\u0263o\u0000\u0001\u0001\u0004\u000e\u0011\u0014\u0018"+ - "\u0019\u001d\u001f!$&,./12446=@MPWZ]_dfgjlny{}\u0082\u0085\u0087\u0088"+ - "\u008c\u008c\u008e\u009a\u009c\u009c\u009f\u00a6\u00a8\u00aa\u00ac\u00ad"+ - "\u00b0\u00b2\u00b6\u00b7\u00ba\u00bb\u00bd\u00c1\u00c4\u00c6\u00c8\u00ca"+ - "\u00cc\u00d1\u00d3\u00d5\u00d7\u00d9\u00dd\u00e2\u00e4\u00e4\u00e6\u00ea"+ - "\u00ee\u00f6\u00f8\u00f9\u00fb\u00fc\u00fe\u0103\u0105\u0108\u010a\u010d"+ - "\u010f\u010f\u0113\u011b\u011d\u011e\u0120\u0120\u0122\u0122\u0125\u0128"+ - "\u012b\u012d\u0130\u0132\u0134\u0134\u0137\u013a\u013d\u0142\u0144\u0144"+ - "\u0146\u0146\u0148\u0156\u0158\u0160\u0162\u0167\u016a\u016c\u016e\u016f"+ - "\u0171\u0171\u0173\u017c\u017e\u017f\u0182\u0182\u0184\u0186\u0189\u018c"+ - "\u018e\u018f\u0191\u019b\u019e\u01a5\u01a7\u01a7\u01a9\u01aa\u01ac\u01ae"+ - "\u01b1\u01b1\u01b3\u01b3\u01b5\u01b9\u01bb\u01c0\u01c2\u01c4\u01c6\u01cb"+ - "\u01cd\u01d6\u01d8\u01e0\u01e2\u01fd\u01ff\u0205\u0207\u020b\u020d\u020e"+ - "\u0210\u0210\u0212\u022d\u022f\u022f\u0231\u0232\u0234\u0236\u0238\u0238"+ - "\u023a\u023d\u0241\u0245\u0249\u024a\u024c\u0262\u0265\u0266\u0268\u026d"+ - "\u026f\u0272\u0274\u0275\u0277\u027c\u027f\u027f\u0281\u0282\u0284\u0284"+ - "\u0286\u0286\u0289\u028c\u028e\u028e\u0290\u0290\u02b9\u02b9\u02f1\u02f1"+ - "\u1a10\u0000\u0222\u0001\u0000\u0000\u0000\u0002\u0263\u0001\u0000\u0000"+ - "\u0000\u0004\u0265\u0001\u0000\u0000\u0000\u0006\u028f\u0001\u0000\u0000"+ - "\u0000\b\u02af\u0001\u0000\u0000\u0000\n\u02cc\u0001\u0000\u0000\u0000"+ - "\f\u02e3\u0001\u0000\u0000\u0000\u000e\u02e5\u0001\u0000\u0000\u0000\u0010"+ - "\u02e7\u0001\u0000\u0000\u0000\u0012\u0335\u0001\u0000\u0000\u0000\u0014"+ - "\u0358\u0001\u0000\u0000\u0000\u0016\u0369\u0001\u0000\u0000\u0000\u0018"+ - "\u036b\u0001\u0000\u0000\u0000\u001a\u0419\u0001\u0000\u0000\u0000\u001c"+ - "\u041b\u0001\u0000\u0000\u0000\u001e\u0461\u0001\u0000\u0000\u0000 \u0463"+ - "\u0001\u0000\u0000\u0000\"\u047a\u0001\u0000\u0000\u0000$\u04c2\u0001"+ - "\u0000\u0000\u0000&\u04db\u0001\u0000\u0000\u0000(\u04dd\u0001\u0000\u0000"+ - "\u0000*\u04e8\u0001\u0000\u0000\u0000,\u04ea\u0001\u0000\u0000\u0000."+ - "\u050d\u0001\u0000\u0000\u00000\u050f\u0001\u0000\u0000\u00002\u052c\u0001"+ - "\u0000\u0000\u00004\u0562\u0001\u0000\u0000\u00006\u057d\u0001\u0000\u0000"+ - "\u00008\u05cd\u0001\u0000\u0000\u0000:\u05cf\u0001\u0000\u0000\u0000<"+ - "\u05e9\u0001\u0000\u0000\u0000>\u05eb\u0001\u0000\u0000\u0000@\u05f4\u0001"+ - "\u0000\u0000\u0000B\u0625\u0001\u0000\u0000\u0000D\u063f\u0001\u0000\u0000"+ - "\u0000F\u0680\u0001\u0000\u0000\u0000H\u0690\u0001\u0000\u0000\u0000J"+ - "\u0692\u0001\u0000\u0000\u0000L\u06b5\u0001\u0000\u0000\u0000N\u0712\u0001"+ - "\u0000\u0000\u0000P\u0714\u0001\u0000\u0000\u0000R\u0716\u0001\u0000\u0000"+ - "\u0000T\u072a\u0001\u0000\u0000\u0000V\u073f\u0001\u0000\u0000\u0000X"+ - "\u0741\u0001\u0000\u0000\u0000Z\u0743\u0001\u0000\u0000\u0000\\\u0745"+ - "\u0001\u0000\u0000\u0000^\u0751\u0001\u0000\u0000\u0000`\u0753\u0001\u0000"+ - "\u0000\u0000b\u075e\u0001\u0000\u0000\u0000d\u0760\u0001\u0000\u0000\u0000"+ - "f\u0762\u0001\u0000\u0000\u0000h\u0764\u0001\u0000\u0000\u0000j\u0766"+ - "\u0001\u0000\u0000\u0000l\u0768\u0001\u0000\u0000\u0000n\u0791\u0001\u0000"+ - "\u0000\u0000p\u0793\u0001\u0000\u0000\u0000r\u08b6\u0001\u0000\u0000\u0000"+ - "t\u08b8\u0001\u0000\u0000\u0000v\u08e6\u0001\u0000\u0000\u0000x\u08e8"+ - "\u0001\u0000\u0000\u0000z\u0907\u0001\u0000\u0000\u0000|\u0909\u0001\u0000"+ - "\u0000\u0000~\u0916\u0001\u0000\u0000\u0000\u0080\u094c\u0001\u0000\u0000"+ - "\u0000\u0082\u0958\u0001\u0000\u0000\u0000\u0084\u0969\u0001\u0000\u0000"+ - "\u0000\u0086\u097c\u0001\u0000\u0000\u0000\u0088\u098c\u0001\u0000\u0000"+ - "\u0000\u008a\u0995\u0001\u0000\u0000\u0000\u008c\u09b0\u0001\u0000\u0000"+ - "\u0000\u008e\u09d5\u0001\u0000\u0000\u0000\u0090\u09dd\u0001\u0000\u0000"+ - "\u0000\u0092\u0a0b\u0001\u0000\u0000\u0000\u0094\u0a4a\u0001\u0000\u0000"+ - "\u0000\u0096\u0a4c\u0001\u0000\u0000\u0000\u0098\u0a6b\u0001\u0000\u0000"+ - "\u0000\u009a\u0abe\u0001\u0000\u0000\u0000\u009c\u0ac0\u0001\u0000\u0000"+ - "\u0000\u009e\u0ad9\u0001\u0000\u0000\u0000\u00a0\u0ae0\u0001\u0000\u0000"+ - "\u0000\u00a2\u0afc\u0001\u0000\u0000\u0000\u00a4\u0b2f\u0001\u0000\u0000"+ - "\u0000\u00a6\u0b31\u0001\u0000\u0000\u0000\u00a8\u0b6b\u0001\u0000\u0000"+ - "\u0000\u00aa\u0b6d\u0001\u0000\u0000\u0000\u00ac\u0ba7\u0001\u0000\u0000"+ - "\u0000\u00ae\u0ba9\u0001\u0000\u0000\u0000\u00b0\u0bab\u0001\u0000\u0000"+ - "\u0000\u00b2\u0bad\u0001\u0000\u0000\u0000\u00b4\u0baf\u0001\u0000\u0000"+ - "\u0000\u00b6\u0bb1\u0001\u0000\u0000\u0000\u00b8\u0bb3\u0001\u0000\u0000"+ - "\u0000\u00ba\u0bb5\u0001\u0000\u0000\u0000\u00bc\u0bb7\u0001\u0000\u0000"+ - "\u0000\u00be\u0bb9\u0001\u0000\u0000\u0000\u00c0\u0bbb\u0001\u0000\u0000"+ - "\u0000\u00c2\u0bbd\u0001\u0000\u0000\u0000\u00c4\u0bbf\u0001\u0000\u0000"+ - "\u0000\u00c6\u0bc1\u0001\u0000\u0000\u0000\u00c8\u0bc3\u0001\u0000\u0000"+ - "\u0000\u00ca\u0bc5\u0001\u0000\u0000\u0000\u00cc\u0bec\u0001\u0000\u0000"+ - "\u0000\u00ce\u0bee\u0001\u0000\u0000\u0000\u00d0\u0bf1\u0001\u0000\u0000"+ - "\u0000\u00d2\u0c10\u0001\u0000\u0000\u0000\u00d4\u0c3c\u0001\u0000\u0000"+ - "\u0000\u00d6\u0c3e\u0001\u0000\u0000\u0000\u00d8\u0c49\u0001\u0000\u0000"+ - "\u0000\u00da\u0c54\u0001\u0000\u0000\u0000\u00dc\u0c62\u0001\u0000\u0000"+ - "\u0000\u00de\u0c6c\u0001\u0000\u0000\u0000\u00e0\u0c76\u0001\u0000\u0000"+ - "\u0000\u00e2\u0c7e\u0001\u0000\u0000\u0000\u00e4\u0c88\u0001\u0000\u0000"+ - "\u0000\u00e6\u0c93\u0001\u0000\u0000\u0000\u00e8\u0c9d\u0001\u0000\u0000"+ - "\u0000\u00ea\u0ca9\u0001\u0000\u0000\u0000\u00ec\u0cb4\u0001\u0000\u0000"+ - "\u0000\u00ee\u0cbe\u0001\u0000\u0000\u0000\u00f0\u0cc6\u0001\u0000\u0000"+ - "\u0000\u00f2\u0cd3\u0001\u0000\u0000\u0000\u00f4\u0ce0\u0001\u0000\u0000"+ - "\u0000\u00f6\u0ceb\u0001\u0000\u0000\u0000\u00f8\u0ced\u0001\u0000\u0000"+ - "\u0000\u00fa\u0cfa\u0001\u0000\u0000\u0000\u00fc\u0d07\u0001\u0000\u0000"+ - "\u0000\u00fe\u0d0e\u0001\u0000\u0000\u0000\u0100\u0d1a\u0001\u0000\u0000"+ - "\u0000\u0102\u0d24\u0001\u0000\u0000\u0000\u0104\u0d2c\u0001\u0000\u0000"+ - "\u0000\u0106\u0d38\u0001\u0000\u0000\u0000\u0108\u0d42\u0001\u0000\u0000"+ - "\u0000\u010a\u0d4c\u0001\u0000\u0000\u0000\u010c\u0d56\u0001\u0000\u0000"+ - "\u0000\u010e\u0d5e\u0001\u0000\u0000\u0000\u0110\u0d68\u0001\u0000\u0000"+ - "\u0000\u0112\u0d72\u0001\u0000\u0000\u0000\u0114\u0d7a\u0001\u0000\u0000"+ - "\u0000\u0116\u0d86\u0001\u0000\u0000\u0000\u0118\u0d92\u0001\u0000\u0000"+ - "\u0000\u011a\u0d9e\u0001\u0000\u0000\u0000\u011c\u0daa\u0001\u0000\u0000"+ - "\u0000\u011e\u0db6\u0001\u0000\u0000\u0000\u0120\u0dc2\u0001\u0000\u0000"+ - "\u0000\u0122\u0dcc\u0001\u0000\u0000\u0000\u0124\u0dd4\u0001\u0000\u0000"+ - "\u0000\u0126\u0de6\u0001\u0000\u0000\u0000\u0128\u0df0\u0001\u0000\u0000"+ - "\u0000\u012a\u0e08\u0001\u0000\u0000\u0000\u012c\u0e15\u0001\u0000\u0000"+ - "\u0000\u012e\u0e17\u0001\u0000\u0000\u0000\u0130\u0e19\u0001\u0000\u0000"+ - "\u0000\u0132\u0e1c\u0001\u0000\u0000\u0000\u0134\u0e58\u0001\u0000\u0000"+ - "\u0000\u0136\u0e5b\u0001\u0000\u0000\u0000\u0138\u0e5d\u0001\u0000\u0000"+ - "\u0000\u013a\u0e81\u0001\u0000\u0000\u0000\u013c\u0e9f\u0001\u0000\u0000"+ - "\u0000\u013e\u0ea5\u0001\u0000\u0000\u0000\u0140\u0eb5\u0001\u0000\u0000"+ - "\u0000\u0142\u0eb9\u0001\u0000\u0000\u0000\u0144\u0ed2\u0001\u0000\u0000"+ - "\u0000\u0146\u0ed4\u0001\u0000\u0000\u0000\u0148\u0edd\u0001\u0000\u0000"+ - "\u0000\u014a\u0ee3\u0001\u0000\u0000\u0000\u014c\u0ee8\u0001\u0000\u0000"+ - "\u0000\u014e\u0eea\u0001\u0000\u0000\u0000\u0150\u0eee\u0001\u0000\u0000"+ - "\u0000\u0152\u0ef2\u0001\u0000\u0000\u0000\u0154\u0efc\u0001\u0000\u0000"+ - "\u0000\u0156\u0eff\u0001\u0000\u0000\u0000\u0158\u0f42\u0001\u0000\u0000"+ - "\u0000\u015a\u0f7f\u0001\u0000\u0000\u0000\u015c\u0fc3\u0001\u0000\u0000"+ - "\u0000\u015e\u0fcf\u0001\u0000\u0000\u0000\u0160\u0ff6\u0001\u0000\u0000"+ - "\u0000\u0162\u0ff8\u0001\u0000\u0000\u0000\u0164\u100b\u0001\u0000\u0000"+ - "\u0000\u0166\u100d\u0001\u0000\u0000\u0000\u0168\u1022\u0001\u0000\u0000"+ - "\u0000\u016a\u1024\u0001\u0000\u0000\u0000\u016c\u1039\u0001\u0000\u0000"+ - "\u0000\u016e\u103b\u0001\u0000\u0000\u0000\u0170\u1042\u0001\u0000\u0000"+ - "\u0000\u0172\u105b\u0001\u0000\u0000\u0000\u0174\u1061\u0001\u0000\u0000"+ - "\u0000\u0176\u1080\u0001\u0000\u0000\u0000\u0178\u1082\u0001\u0000\u0000"+ - "\u0000\u017a\u10b9\u0001\u0000\u0000\u0000\u017c\u10bc\u0001\u0000\u0000"+ - "\u0000\u017e\u10e6\u0001\u0000\u0000\u0000\u0180\u10ea\u0001\u0000\u0000"+ - "\u0000\u0182\u10f3\u0001\u0000\u0000\u0000\u0184\u10f6\u0001\u0000\u0000"+ - "\u0000\u0186\u1119\u0001\u0000\u0000\u0000\u0188\u111b\u0001\u0000\u0000"+ - "\u0000\u018a\u1126\u0001\u0000\u0000\u0000\u018c\u1137\u0001\u0000\u0000"+ - "\u0000\u018e\u114f\u0001\u0000\u0000\u0000\u0190\u115d\u0001\u0000\u0000"+ - "\u0000\u0192\u115f\u0001\u0000\u0000\u0000\u0194\u1161\u0001\u0000\u0000"+ - "\u0000\u0196\u116b\u0001\u0000\u0000\u0000\u0198\u116d\u0001\u0000\u0000"+ - "\u0000\u019a\u1175\u0001\u0000\u0000\u0000\u019c\u1179\u0001\u0000\u0000"+ - "\u0000\u019e\u117c\u0001\u0000\u0000\u0000\u01a0\u118b\u0001\u0000\u0000"+ - "\u0000\u01a2\u1195\u0001\u0000\u0000\u0000\u01a4\u119a\u0001\u0000\u0000"+ - "\u0000\u01a6\u11b1\u0001\u0000\u0000\u0000\u01a8\u11bd\u0001\u0000\u0000"+ - "\u0000\u01aa\u11d2\u0001\u0000\u0000\u0000\u01ac\u11d8\u0001\u0000\u0000"+ - "\u0000\u01ae\u11dd\u0001\u0000\u0000\u0000\u01b0\u11e5\u0001\u0000\u0000"+ - "\u0000\u01b2\u1202\u0001\u0000\u0000\u0000\u01b4\u1213\u0001\u0000\u0000"+ - "\u0000\u01b6\u1215\u0001\u0000\u0000\u0000\u01b8\u1266\u0001\u0000\u0000"+ - "\u0000\u01ba\u12e0\u0001\u0000\u0000\u0000\u01bc\u12e4\u0001\u0000\u0000"+ - "\u0000\u01be\u12e8\u0001\u0000\u0000\u0000\u01c0\u12ef\u0001\u0000\u0000"+ - "\u0000\u01c2\u131d\u0001\u0000\u0000\u0000\u01c4\u131f\u0001\u0000\u0000"+ - "\u0000\u01c6\u132b\u0001\u0000\u0000\u0000\u01c8\u133f\u0001\u0000\u0000"+ - "\u0000\u01ca\u1341\u0001\u0000\u0000\u0000\u01cc\u1349\u0001\u0000\u0000"+ - "\u0000\u01ce\u1350\u0001\u0000\u0000\u0000\u01d0\u13e8\u0001\u0000\u0000"+ - "\u0000\u01d2\u13ea\u0001\u0000\u0000\u0000\u01d4\u13f0\u0001\u0000\u0000"+ - "\u0000\u01d6\u1431\u0001\u0000\u0000\u0000\u01d8\u1435\u0001\u0000\u0000"+ - "\u0000\u01da\u1437\u0001\u0000\u0000\u0000\u01dc\u143f\u0001\u0000\u0000"+ - "\u0000\u01de\u1447\u0001\u0000\u0000\u0000\u01e0\u144c\u0001\u0000\u0000"+ - "\u0000\u01e2\u1454\u0001\u0000\u0000\u0000\u01e4\u1458\u0001\u0000\u0000"+ - "\u0000\u01e6\u1464\u0001\u0000\u0000\u0000\u01e8\u146e\u0001\u0000\u0000"+ - "\u0000\u01ea\u1470\u0001\u0000\u0000\u0000\u01ec\u1496\u0001\u0000\u0000"+ - "\u0000\u01ee\u1498\u0001\u0000\u0000\u0000\u01f0\u1510\u0001\u0000\u0000"+ - "\u0000\u01f2\u153c\u0001\u0000\u0000\u0000\u01f4\u1553\u0001\u0000\u0000"+ - "\u0000\u01f6\u1563\u0001\u0000\u0000\u0000\u01f8\u1571\u0001\u0000\u0000"+ - "\u0000\u01fa\u1598\u0001\u0000\u0000\u0000\u01fc\u159a\u0001\u0000\u0000"+ - "\u0000\u01fe\u159e\u0001\u0000\u0000\u0000\u0200\u15a7\u0001\u0000\u0000"+ - "\u0000\u0202\u15b4\u0001\u0000\u0000\u0000\u0204\u15c2\u0001\u0000\u0000"+ - "\u0000\u0206\u1615\u0001\u0000\u0000\u0000\u0208\u1617\u0001\u0000\u0000"+ - "\u0000\u020a\u162a\u0001\u0000\u0000\u0000\u020c\u162c\u0001\u0000\u0000"+ - "\u0000\u020e\u162e\u0001\u0000\u0000\u0000\u0210\u1636\u0001\u0000\u0000"+ - "\u0000\u0212\u1640\u0001\u0000\u0000\u0000\u0214\u1642\u0001\u0000\u0000"+ - "\u0000\u0216\u1644\u0001\u0000\u0000\u0000\u0218\u1646\u0001\u0000\u0000"+ - "\u0000\u021a\u1648\u0001\u0000\u0000\u0000\u021c\u164a\u0001\u0000\u0000"+ - "\u0000\u021e\u164c\u0001\u0000\u0000\u0000\u0220\u164e\u0001\u0000\u0000"+ - "\u0000\u0222\u022b\u0003\u0002\u0001\u0000\u0223\u0224\u0005\u0344\u0000"+ - "\u0000\u0224\u0226\u0003\u0002\u0001\u0000\u0225\u0223\u0001\u0000\u0000"+ - "\u0000\u0226\u0229\u0001\u0000\u0000\u0000\u0227\u0225\u0001\u0000\u0000"+ - "\u0000\u0227\u0228\u0001\u0000\u0000\u0000\u0228\u022a\u0001\u0000\u0000"+ - "\u0000\u0229\u0227\u0001\u0000\u0000\u0000\u022a\u022c\u0005\u0344\u0000"+ - "\u0000\u022b\u0227\u0001\u0000\u0000\u0000\u022b\u022c\u0001\u0000\u0000"+ - "\u0000\u022c\u022d\u0001\u0000\u0000\u0000\u022d\u022e\u0005\u0000\u0000"+ - "\u0001\u022e\u0001\u0001\u0000\u0000\u0000\u022f\u0264\u0003\u0004\u0002"+ - "\u0000\u0230\u0264\u0003\u0006\u0003\u0000\u0231\u0264\u0003`0\u0000\u0232"+ - "\u0264\u0003n7\u0000\u0233\u0264\u0003b1\u0000\u0234\u0264\u0003d2\u0000"+ - "\u0235\u0264\u0003f3\u0000\u0236\u0264\u0003h4\u0000\u0237\u0264\u0003"+ - "j5\u0000\u0238\u0264\u0003l6\u0000\u0239\u0264\u0003\u00ccf\u0000\u023a"+ - "\u0264\u0003\u00ceg\u0000\u023b\u0264\u0003\u00d0h\u0000\u023c\u0264\u0003"+ - "\u00d2i\u0000\u023d\u0264\u0003\u00d4j\u0000\u023e\u0264\u0003\u0128\u0094"+ - "\u0000\u023f\u0264\u0003\u012a\u0095\u0000\u0240\u0264\u0003\u012c\u0096"+ - "\u0000\u0241\u0264\u0003\u012e\u0097\u0000\u0242\u0264\u0003\u0130\u0098"+ - "\u0000\u0243\u0264\u0003\u0132\u0099\u0000\u0244\u0264\u0003\u0134\u009a"+ - "\u0000\u0245\u0264\u0003\u0136\u009b\u0000\u0246\u0264\u0003\u0138\u009c"+ - "\u0000\u0247\u0264\u0003\u013a\u009d\u0000\u0248\u0264\u0003\u013c\u009e"+ - "\u0000\u0249\u0264\u0003\u013e\u009f\u0000\u024a\u0264\u0003\u0140\u00a0"+ - "\u0000\u024b\u0264\u0003\u0142\u00a1\u0000\u024c\u0264\u0003\u0144\u00a2"+ - "\u0000\u024d\u0264\u0003\u0146\u00a3\u0000\u024e\u0264\u0003\u0148\u00a4"+ - "\u0000\u024f\u0264\u0003\u014a\u00a5\u0000\u0250\u0264\u0003\u014c\u00a6"+ - "\u0000\u0251\u0264\u0003\u014e\u00a7\u0000\u0252\u0264\u0003\u0150\u00a8"+ - "\u0000\u0253\u0264\u0003\u0152\u00a9\u0000\u0254\u0264\u0003\u0154\u00aa"+ - "\u0000\u0255\u0264\u0003\u0156\u00ab\u0000\u0256\u0264\u0003\u0158\u00ac"+ - "\u0000\u0257\u0264\u0003\u015a\u00ad\u0000\u0258\u0264\u0003\u0160\u00b0"+ - "\u0000\u0259\u0264\u0003\u0162\u00b1\u0000\u025a\u0264\u0003\u0164\u00b2"+ - "\u0000\u025b\u0264\u0003\u0166\u00b3\u0000\u025c\u0264\u0003\u016c\u00b6"+ - "\u0000\u025d\u0264\u0003\u016e\u00b7\u0000\u025e\u0264\u0003\u0170\u00b8"+ - "\u0000\u025f\u0264\u0003\u0172\u00b9\u0000\u0260\u0264\u0003\u0174\u00ba"+ - "\u0000\u0261\u0264\u0003\u017a\u00bd\u0000\u0262\u0264\u0003\u017c\u00be"+ - "\u0000\u0263\u022f\u0001\u0000\u0000\u0000\u0263\u0230\u0001\u0000\u0000"+ - "\u0000\u0263\u0231\u0001\u0000\u0000\u0000\u0263\u0232\u0001\u0000\u0000"+ - "\u0000\u0263\u0233\u0001\u0000\u0000\u0000\u0263\u0234\u0001\u0000\u0000"+ - "\u0000\u0263\u0235\u0001\u0000\u0000\u0000\u0263\u0236\u0001\u0000\u0000"+ - "\u0000\u0263\u0237\u0001\u0000\u0000\u0000\u0263\u0238\u0001\u0000\u0000"+ - "\u0000\u0263\u0239\u0001\u0000\u0000\u0000\u0263\u023a\u0001\u0000\u0000"+ - "\u0000\u0263\u023b\u0001\u0000\u0000\u0000\u0263\u023c\u0001\u0000\u0000"+ - "\u0000\u0263\u023d\u0001\u0000\u0000\u0000\u0263\u023e\u0001\u0000\u0000"+ - "\u0000\u0263\u023f\u0001\u0000\u0000\u0000\u0263\u0240\u0001\u0000\u0000"+ - "\u0000\u0263\u0241\u0001\u0000\u0000\u0000\u0263\u0242\u0001\u0000\u0000"+ - "\u0000\u0263\u0243\u0001\u0000\u0000\u0000\u0263\u0244\u0001\u0000\u0000"+ - "\u0000\u0263\u0245\u0001\u0000\u0000\u0000\u0263\u0246\u0001\u0000\u0000"+ - "\u0000\u0263\u0247\u0001\u0000\u0000\u0000\u0263\u0248\u0001\u0000\u0000"+ - "\u0000\u0263\u0249\u0001\u0000\u0000\u0000\u0263\u024a\u0001\u0000\u0000"+ - "\u0000\u0263\u024b\u0001\u0000\u0000\u0000\u0263\u024c\u0001\u0000\u0000"+ - "\u0000\u0263\u024d\u0001\u0000\u0000\u0000\u0263\u024e\u0001\u0000\u0000"+ - "\u0000\u0263\u024f\u0001\u0000\u0000\u0000\u0263\u0250\u0001\u0000\u0000"+ - "\u0000\u0263\u0251\u0001\u0000\u0000\u0000\u0263\u0252\u0001\u0000\u0000"+ - "\u0000\u0263\u0253\u0001\u0000\u0000\u0000\u0263\u0254\u0001\u0000\u0000"+ - "\u0000\u0263\u0255\u0001\u0000\u0000\u0000\u0263\u0256\u0001\u0000\u0000"+ - "\u0000\u0263\u0257\u0001\u0000\u0000\u0000\u0263\u0258\u0001\u0000\u0000"+ - "\u0000\u0263\u0259\u0001\u0000\u0000\u0000\u0263\u025a\u0001\u0000\u0000"+ - "\u0000\u0263\u025b\u0001\u0000\u0000\u0000\u0263\u025c\u0001\u0000\u0000"+ - "\u0000\u0263\u025d\u0001\u0000\u0000\u0000\u0263\u025e\u0001\u0000\u0000"+ - "\u0000\u0263\u025f\u0001\u0000\u0000\u0000\u0263\u0260\u0001\u0000\u0000"+ - "\u0000\u0263\u0261\u0001\u0000\u0000\u0000\u0263\u0262\u0001\u0000\u0000"+ - "\u0000\u0264\u0003\u0001\u0000\u0000\u0000\u0265\u0266\u0003\u0210\u0108"+ - "\u0000\u0266\u0005\u0001\u0000\u0000\u0000\u0267\u0290\u0003\b\u0004\u0000"+ - "\u0268\u0290\u0003\n\u0005\u0000\u0269\u0290\u0003\f\u0006\u0000\u026a"+ - "\u0290\u0003\u000e\u0007\u0000\u026b\u0290\u0003\u0010\b\u0000\u026c\u0290"+ - "\u0003\u0012\t\u0000\u026d\u0290\u0003\u0014\n\u0000\u026e\u0290\u0003"+ - "\u0016\u000b\u0000\u026f\u0290\u0003\u0018\f\u0000\u0270\u0290\u0003\u001e"+ - "\u000f\u0000\u0271\u0290\u0003 \u0010\u0000\u0272\u0290\u0003\"\u0011"+ - "\u0000\u0273\u0290\u0003$\u0012\u0000\u0274\u0290\u0003&\u0013\u0000\u0275"+ - "\u0290\u0003(\u0014\u0000\u0276\u0290\u0003*\u0015\u0000\u0277\u0290\u0003"+ - ",\u0016\u0000\u0278\u0290\u0003.\u0017\u0000\u0279\u0290\u00030\u0018"+ - "\u0000\u027a\u0290\u00032\u0019\u0000\u027b\u0290\u00034\u001a\u0000\u027c"+ - "\u0290\u00038\u001c\u0000\u027d\u0290\u0003:\u001d\u0000\u027e\u0290\u0003"+ - "<\u001e\u0000\u027f\u0290\u0003>\u001f\u0000\u0280\u0290\u0003B!\u0000"+ - "\u0281\u0290\u0003D\"\u0000\u0282\u0290\u0003F#\u0000\u0283\u0290\u0003"+ - "H$\u0000\u0284\u0290\u0003J%\u0000\u0285\u0290\u0003L&\u0000\u0286\u0290"+ - "\u0003N\'\u0000\u0287\u0290\u0003P(\u0000\u0288\u0290\u0003R)\u0000\u0289"+ - "\u0290\u0003T*\u0000\u028a\u0290\u0003V+\u0000\u028b\u0290\u0003X,\u0000"+ - "\u028c\u0290\u0003Z-\u0000\u028d\u0290\u0003\\.\u0000\u028e\u0290\u0003"+ - "^/\u0000\u028f\u0267\u0001\u0000\u0000\u0000\u028f\u0268\u0001\u0000\u0000"+ - "\u0000\u028f\u0269\u0001\u0000\u0000\u0000\u028f\u026a\u0001\u0000\u0000"+ - "\u0000\u028f\u026b\u0001\u0000\u0000\u0000\u028f\u026c\u0001\u0000\u0000"+ - "\u0000\u028f\u026d\u0001\u0000\u0000\u0000\u028f\u026e\u0001\u0000\u0000"+ - "\u0000\u028f\u026f\u0001\u0000\u0000\u0000\u028f\u0270\u0001\u0000\u0000"+ - "\u0000\u028f\u0271\u0001\u0000\u0000\u0000\u028f\u0272\u0001\u0000\u0000"+ - "\u0000\u028f\u0273\u0001\u0000\u0000\u0000\u028f\u0274\u0001\u0000\u0000"+ - "\u0000\u028f\u0275\u0001\u0000\u0000\u0000\u028f\u0276\u0001\u0000\u0000"+ - "\u0000\u028f\u0277\u0001\u0000\u0000\u0000\u028f\u0278\u0001\u0000\u0000"+ - "\u0000\u028f\u0279\u0001\u0000\u0000\u0000\u028f\u027a\u0001\u0000\u0000"+ - "\u0000\u028f\u027b\u0001\u0000\u0000\u0000\u028f\u027c\u0001\u0000\u0000"+ - "\u0000\u028f\u027d\u0001\u0000\u0000\u0000\u028f\u027e\u0001\u0000\u0000"+ - "\u0000\u028f\u027f\u0001\u0000\u0000\u0000\u028f\u0280\u0001\u0000\u0000"+ - "\u0000\u028f\u0281\u0001\u0000\u0000\u0000\u028f\u0282\u0001\u0000\u0000"+ - "\u0000\u028f\u0283\u0001\u0000\u0000\u0000\u028f\u0284\u0001\u0000\u0000"+ - "\u0000\u028f\u0285\u0001\u0000\u0000\u0000\u028f\u0286\u0001\u0000\u0000"+ - "\u0000\u028f\u0287\u0001\u0000\u0000\u0000\u028f\u0288\u0001\u0000\u0000"+ - "\u0000\u028f\u0289\u0001\u0000\u0000\u0000\u028f\u028a\u0001\u0000\u0000"+ - "\u0000\u028f\u028b\u0001\u0000\u0000\u0000\u028f\u028c\u0001\u0000\u0000"+ - "\u0000\u028f\u028d\u0001\u0000\u0000\u0000\u028f\u028e\u0001\u0000\u0000"+ - "\u0000\u0290\u0007\u0001\u0000\u0000\u0000\u0291\u0292\u0005\u0013\u0000"+ - "\u0000\u0292\u0293\u0005\u000e\u0000\u0000\u0293\u0294\u0003\u0210\u0108"+ - "\u0000\u0294\u0295\u0005\u0300\u0000\u0000\u0295\u0296\u0003\u01fa\u00fd"+ - "\u0000\u0296\u0297\u0005\u0301\u0000\u0000\u0297\u0298\u0005\u01d4\u0000"+ - "\u0000\u0298\u0299\u0005\u0247\u0000\u0000\u0299\u029a\u0003\u0210\u0108"+ - "\u0000\u029a\u02b0\u0001\u0000\u0000\u0000\u029b\u029c\u0005\u0013\u0000"+ - "\u0000\u029c\u029d\u0005\u000e\u0000\u0000\u029d\u029e\u0003\u0210\u0108"+ - "\u0000\u029e\u029f\u0005\u0300\u0000\u0000\u029f\u02a0\u0003\u01fa\u00fd"+ - "\u0000\u02a0\u02a1\u0005\u0301\u0000\u0000\u02a1\u02a2\u0005\u0193\u0000"+ - "\u0000\u02a2\u02a3\u0005\u0247\u0000\u0000\u02a3\u02a4\u0003\u0206\u0103"+ - "\u0000\u02a4\u02b0\u0001\u0000\u0000\u0000\u02a5\u02a6\u0005\u0013\u0000"+ - "\u0000\u02a6\u02a7\u0005\u000e\u0000\u0000\u02a7\u02a8\u0003\u0210\u0108"+ - "\u0000\u02a8\u02a9\u0005\u0300\u0000\u0000\u02a9\u02aa\u0003\u01fa\u00fd"+ - "\u0000\u02aa\u02ab\u0005\u0301\u0000\u0000\u02ab\u02ac\u0005\u0207\u0000"+ - "\u0000\u02ac\u02ad\u0005\u01f3\u0000\u0000\u02ad\u02ae\u0003\u0210\u0108"+ - "\u0000\u02ae\u02b0\u0001\u0000\u0000\u0000\u02af\u0291\u0001\u0000\u0000"+ - "\u0000\u02af\u029b\u0001\u0000\u0000\u0000\u02af\u02a5\u0001\u0000\u0000"+ - "\u0000\u02b0\t\u0001\u0000\u0000\u0000\u02b1\u02b2\u0005\u0013\u0000\u0000"+ - "\u02b2\u02b3\u0005Y\u0000\u0000\u02b3\u02b4\u0003\u01d8\u00ec\u0000\u02b4"+ - "\u02b5\u0005\u01c7\u0000\u0000\u02b5\u02b6\u0005\u02b9\u0000\u0000\u02b6"+ - "\u02cd\u0001\u0000\u0000\u0000\u02b7\u02b8\u0005\u0013\u0000\u0000\u02b8"+ - "\u02b9\u0005Y\u0000\u0000\u02b9\u02ba\u0003\u01d8\u00ec\u0000\u02ba\u02bb"+ - "\u0005\u01d4\u0000\u0000\u02bb\u02bc\u0005\u0247\u0000\u0000\u02bc\u02bd"+ - "\u0003\u0210\u0108\u0000\u02bd\u02cd\u0001\u0000\u0000\u0000\u02be\u02bf"+ - "\u0005\u0013\u0000\u0000\u02bf\u02c0\u0005Y\u0000\u0000\u02c0\u02c1\u0003"+ - "\u01d8\u00ec\u0000\u02c1\u02c2\u0005\u0193\u0000\u0000\u02c2\u02c3\u0005"+ - "\u0247\u0000\u0000\u02c3\u02c4\u0003\u0206\u0103\u0000\u02c4\u02cd\u0001"+ - "\u0000\u0000\u0000\u02c5\u02c6\u0005\u0013\u0000\u0000\u02c6\u02c7\u0005"+ - "Y\u0000\u0000\u02c7\u02c8\u0003\u01d8\u00ec\u0000\u02c8\u02c9\u0005\u0207"+ - "\u0000\u0000\u02c9\u02ca\u0005\u01f3\u0000\u0000\u02ca\u02cb\u0003\u0210"+ - "\u0108\u0000\u02cb\u02cd\u0001\u0000\u0000\u0000\u02cc\u02b1\u0001\u0000"+ - "\u0000\u0000\u02cc\u02b7\u0001\u0000\u0000\u0000\u02cc\u02be\u0001\u0000"+ - "\u0000\u0000\u02cc\u02c5\u0001\u0000\u0000\u0000\u02cd\u000b\u0001\u0000"+ - "\u0000\u0000\u02ce\u02cf\u0005\u0013\u0000\u0000\u02cf\u02d0\u0005u\u0000"+ - "\u0000\u02d0\u02d1\u0003\u0210\u0108\u0000\u02d1\u02d2\u0005\u01d4\u0000"+ - "\u0000\u02d2\u02d3\u0005\u0247\u0000\u0000\u02d3\u02d4\u0003\u0210\u0108"+ - "\u0000\u02d4\u02e4\u0001\u0000\u0000\u0000\u02d5\u02d6\u0005\u0013\u0000"+ - "\u0000\u02d6\u02d7\u0005u\u0000\u0000\u02d7\u02d8\u0003\u0210\u0108\u0000"+ - "\u02d8\u02d9\u0005\u0193\u0000\u0000\u02d9\u02da\u0005\u0247\u0000\u0000"+ - "\u02da\u02db\u0003\u0206\u0103\u0000\u02db\u02e4\u0001\u0000\u0000\u0000"+ - "\u02dc\u02dd\u0005\u0013\u0000\u0000\u02dd\u02de\u0005u\u0000\u0000\u02de"+ - "\u02df\u0003\u0210\u0108\u0000\u02df\u02e0\u0005\u0207\u0000\u0000\u02e0"+ - "\u02e1\u0005\u01f3\u0000\u0000\u02e1\u02e2\u0003\u0210\u0108\u0000\u02e2"+ - "\u02e4\u0001\u0000\u0000\u0000\u02e3\u02ce\u0001\u0000\u0000\u0000\u02e3"+ - "\u02d5\u0001\u0000\u0000\u0000\u02e3\u02dc\u0001\u0000\u0000\u0000\u02e4"+ - "\r\u0001\u0000\u0000\u0000\u02e5\u02e6\u0003\u0214\u010a\u0000\u02e6\u000f"+ - "\u0001\u0000\u0000\u0000\u02e7\u02e8\u0003\u0214\u010a\u0000\u02e8\u0011"+ - "\u0001\u0000\u0000\u0000\u02e9\u02ea\u0005\u0013\u0000\u0000\u02ea\u02eb"+ - "\u0005\u00ba\u0000\u0000\u02eb\u02f1\u0003\u0210\u0108\u0000\u02ec\u02ed"+ - "\u0005\u0207\u0000\u0000\u02ed\u02ee\u0005\u009b\u0000\u0000\u02ee\u02f2"+ - "\u0003\u01b8\u00dc\u0000\u02ef\u02f0\u0005\u00bc\u0000\u0000\u02f0\u02f2"+ - "\u0005\u009b\u0000\u0000\u02f1\u02ec\u0001\u0000\u0000\u0000\u02f1\u02ef"+ - "\u0001\u0000\u0000\u0000\u02f2\u0336\u0001\u0000\u0000\u0000\u02f3\u02f4"+ - "\u0005\u0013\u0000\u0000\u02f4\u02f5\u0005\u00ba\u0000\u0000\u02f5\u02f6"+ - "\u0003\u0210\u0108\u0000\u02f6\u02f7\u0007\u0000\u0000\u0000\u02f7\u02f8"+ - "\u0005\u016d\u0000\u0000\u02f8\u02f9\u0005\u0172\u0000\u0000\u02f9\u0336"+ - "\u0001\u0000\u0000\u0000\u02fa\u02fb\u0005\u0013\u0000\u0000\u02fb\u02fc"+ - "\u0005\u00ba\u0000\u0000\u02fc\u02fd\u0003\u0210\u0108\u0000\u02fd\u02fe"+ - "\u0005\u000b\u0000\u0000\u02fe\u0301\u0003\u0080@\u0000\u02ff\u0300\u0005"+ - "\u016d\u0000\u0000\u0300\u0302\u0005\u0275\u0000\u0000\u0301\u02ff\u0001"+ - "\u0000\u0000\u0000\u0301\u0302\u0001\u0000\u0000\u0000\u0302\u0336\u0001"+ - "\u0000\u0000\u0000\u0303\u0304\u0005\u0013\u0000\u0000\u0304\u0305\u0005"+ - "\u00ba\u0000\u0000\u0305\u0306\u0003\u0210\u0108\u0000\u0306\u0307\u0005"+ - "\u00bc\u0000\u0000\u0307\u030a\u0005m\u0000\u0000\u0308\u0309\u0005\u02b4"+ - "\u0000\u0000\u0309\u030b\u0005\u00d3\u0000\u0000\u030a\u0308\u0001\u0000"+ - "\u0000\u0000\u030a\u030b\u0001\u0000\u0000\u0000\u030b\u030c\u0001\u0000"+ - "\u0000\u0000\u030c\u030e\u0003\u0210\u0108\u0000\u030d\u030f\u0007\u0001"+ - "\u0000\u0000\u030e\u030d\u0001\u0000\u0000\u0000\u030e\u030f\u0001\u0000"+ - "\u0000\u0000\u030f\u0336\u0001\u0000\u0000\u0000\u0310\u0311\u0005\u0013"+ - "\u0000\u0000\u0311\u0312\u0005\u00ba\u0000\u0000\u0312\u0313\u0003\u0210"+ - "\u0108\u0000\u0313\u0314\u0005\u01d4\u0000\u0000\u0314\u0315\u0005m\u0000"+ - "\u0000\u0315\u0316\u0003\u0210\u0108\u0000\u0316\u0317\u0005\u0247\u0000"+ - "\u0000\u0317\u0318\u0003\u0210\u0108\u0000\u0318\u0336\u0001\u0000\u0000"+ - "\u0000\u0319\u031a\u0005\u0013\u0000\u0000\u031a\u031b\u0005\u00ba\u0000"+ - "\u0000\u031b\u031c\u0003\u0210\u0108\u0000\u031c\u031d\u0005\u0276\u0000"+ - "\u0000\u031d\u031e\u0005m\u0000\u0000\u031e\u031f\u0003\u0210\u0108\u0000"+ - "\u031f\u0336\u0001\u0000\u0000\u0000\u0320\u0321\u0005\u0013\u0000\u0000"+ - "\u0321\u0322\u0005\u00ba\u0000\u0000\u0322\u0323\u0003\u0210\u0108\u0000"+ - "\u0323\u0324\u0005\u0193\u0000\u0000\u0324\u0325\u0005\u0247\u0000\u0000"+ - "\u0325\u0326\u0003\u0206\u0103\u0000\u0326\u0336\u0001\u0000\u0000\u0000"+ - "\u0327\u0328\u0005\u0013\u0000\u0000\u0328\u0329\u0005\u00ba\u0000\u0000"+ - "\u0329\u032a\u0003\u0210\u0108\u0000\u032a\u032b\u0005\u01d4\u0000\u0000"+ - "\u032b\u032c\u0005\u0247\u0000\u0000\u032c\u032d\u0003\u0210\u0108\u0000"+ - "\u032d\u0336\u0001\u0000\u0000\u0000\u032e\u032f\u0005\u0013\u0000\u0000"+ - "\u032f\u0330\u0005\u00ba\u0000\u0000\u0330\u0331\u0003\u0210\u0108\u0000"+ - "\u0331\u0332\u0005\u0207\u0000\u0000\u0332\u0333\u0005\u01f3\u0000\u0000"+ - "\u0333\u0334\u0003\u0210\u0108\u0000\u0334\u0336\u0001\u0000\u0000\u0000"+ - "\u0335\u02e9\u0001\u0000\u0000\u0000\u0335\u02f3\u0001\u0000\u0000\u0000"+ - "\u0335\u02fa\u0001\u0000\u0000\u0000\u0335\u0303\u0001\u0000\u0000\u0000"+ - "\u0335\u0310\u0001\u0000\u0000\u0000\u0335\u0319\u0001\u0000\u0000\u0000"+ - "\u0335\u0320\u0001\u0000\u0000\u0000\u0335\u0327\u0001\u0000\u0000\u0000"+ - "\u0335\u032e\u0001\u0000\u0000\u0000\u0336\u0013\u0001\u0000\u0000\u0000"+ - "\u0337\u0338\u0005\u0013\u0000\u0000\u0338\u0339\u0005\u02bc\u0000\u0000"+ - "\u0339\u033a\u0005\u0255\u0000\u0000\u033a\u033b\u0003\u0210\u0108\u0000"+ - "\u033b\u033c\u0005\u00b3\u0000\u0000\u033c\u0359\u0001\u0000\u0000\u0000"+ - "\u033d\u033e\u0005\u0013\u0000\u0000\u033e\u033f\u0005\u02bc\u0000\u0000"+ - "\u033f\u0340\u0005\u0255\u0000\u0000\u0340\u0341\u0003\u0210\u0108\u0000"+ - "\u0341\u0343\u0005\u00c3\u0000\u0000\u0342\u0344\u0007\u0002\u0000\u0000"+ - "\u0343\u0342\u0001\u0000\u0000\u0000\u0343\u0344\u0001\u0000\u0000\u0000"+ - "\u0344\u0359\u0001\u0000\u0000\u0000\u0345\u0346\u0005\u0013\u0000\u0000"+ - "\u0346\u0347\u0005\u02bc\u0000\u0000\u0347\u0348\u0005\u0255\u0000\u0000"+ - "\u0348\u0349\u0003\u0210\u0108\u0000\u0349\u034a\u0005\u0193\u0000\u0000"+ - "\u034a\u034e\u0005\u0247\u0000\u0000\u034b\u034f\u0003\u0210\u0108\u0000"+ - "\u034c\u034f\u0005\u008d\u0000\u0000\u034d\u034f\u0005\u0206\u0000\u0000"+ - "\u034e\u034b\u0001\u0000\u0000\u0000\u034e\u034c\u0001\u0000\u0000\u0000"+ - "\u034e\u034d\u0001\u0000\u0000\u0000\u034f\u0359\u0001\u0000\u0000\u0000"+ - "\u0350\u0351\u0005\u0013\u0000\u0000\u0351\u0352\u0005\u02bc\u0000\u0000"+ - "\u0352\u0353\u0005\u0255\u0000\u0000\u0353\u0354\u0003\u0210\u0108\u0000"+ - "\u0354\u0355\u0005\u01d4\u0000\u0000\u0355\u0356\u0005\u0247\u0000\u0000"+ - "\u0356\u0357\u0003\u0210\u0108\u0000\u0357\u0359\u0001\u0000\u0000\u0000"+ - "\u0358\u0337\u0001\u0000\u0000\u0000\u0358\u033d\u0001\u0000\u0000\u0000"+ - "\u0358\u0345\u0001\u0000\u0000\u0000\u0358\u0350\u0001\u0000\u0000\u0000"+ - "\u0359\u0015\u0001\u0000\u0000\u0000\u035a\u035b\u0005\u0013\u0000\u0000"+ - "\u035b\u035c\u0005\u00d7\u0000\u0000\u035c\u035d\u0003\u0210\u0108\u0000"+ - "\u035d\u0360\u0005\u026b\u0000\u0000\u035e\u035f\u0005\u0247\u0000\u0000"+ - "\u035f\u0361\u0003\u0210\u0108\u0000\u0360\u035e\u0001\u0000\u0000\u0000"+ - "\u0360\u0361\u0001\u0000\u0000\u0000\u0361\u036a\u0001\u0000\u0000\u0000"+ - "\u0362\u0363\u0005\u0013\u0000\u0000\u0363\u0364\u0005\u00d7\u0000\u0000"+ - "\u0364\u0365\u0003\u0210\u0108\u0000\u0365\u0366\u0005\u0207\u0000\u0000"+ - "\u0366\u0367\u0005\u01f3\u0000\u0000\u0367\u0368\u0003\u0210\u0108\u0000"+ - "\u0368\u036a\u0001\u0000\u0000\u0000\u0369\u035a\u0001\u0000\u0000\u0000"+ - "\u0369\u0362\u0001\u0000\u0000\u0000\u036a\u0017\u0001\u0000\u0000\u0000"+ - "\u036b\u036c\u0003\u0214\u010a\u0000\u036c\u0019\u0001\u0000\u0000\u0000"+ - "\u036d\u036f\u0005\u000b\u0000\u0000\u036e\u0370\u0005^\u0000\u0000\u036f"+ - "\u036e\u0001\u0000\u0000\u0000\u036f\u0370\u0001\u0000\u0000\u0000\u0370"+ - "\u0371\u0001\u0000\u0000\u0000\u0371\u0372\u0003\u0218\u010c\u0000\u0372"+ - "\u0375\u0003\u01e4\u00f2\u0000\u0373\u0374\u0005X\u0000\u0000\u0374\u0376"+ - "\u0003\u0210\u0108\u0000\u0375\u0373\u0001\u0000\u0000\u0000\u0375\u0376"+ - "\u0001\u0000\u0000\u0000\u0376\u0378\u0001\u0000\u0000\u0000\u0377\u0379"+ - "\u0003\u01fe\u00ff\u0000\u0378\u0377\u0001\u0000\u0000\u0000\u0378\u0379"+ - "\u0001\u0000\u0000\u0000\u0379\u041a\u0001\u0000\u0000\u0000\u037a\u037c"+ - "\u0005\u00bc\u0000\u0000\u037b\u037d\u0005^\u0000\u0000\u037c\u037b\u0001"+ - "\u0000\u0000\u0000\u037c\u037d\u0001\u0000\u0000\u0000\u037d\u0380\u0001"+ - "\u0000\u0000\u0000\u037e\u037f\u0005\u02b4\u0000\u0000\u037f\u0381\u0005"+ - "\u00d3\u0000\u0000\u0380\u037e\u0001\u0000\u0000\u0000\u0380\u0381\u0001"+ - "\u0000\u0000\u0000\u0381\u0382\u0001\u0000\u0000\u0000\u0382\u0384\u0003"+ - "\u0218\u010c\u0000\u0383\u0385\u0007\u0001\u0000\u0000\u0384\u0383\u0001"+ - "\u0000\u0000\u0000\u0384\u0385\u0001\u0000\u0000\u0000\u0385\u041a\u0001"+ - "\u0000\u0000\u0000\u0386\u0388\u0005\u0013\u0000\u0000\u0387\u0389\u0005"+ - "^\u0000\u0000\u0388\u0387\u0001\u0000\u0000\u0000\u0388\u0389\u0001\u0000"+ - "\u0000\u0000\u0389\u038a\u0001\u0000\u0000\u0000\u038a\u038d\u0003\u0218"+ - "\u010c\u0000\u038b\u038c\u0005\u0207\u0000\u0000\u038c\u038e\u0005\u0091"+ - "\u0000\u0000\u038d\u038b\u0001\u0000\u0000\u0000\u038d\u038e\u0001\u0000"+ - "\u0000\u0000\u038e\u038f\u0001\u0000\u0000\u0000\u038f\u0390\u0005\u025d"+ - "\u0000\u0000\u0390\u0393\u0003\u01e4\u00f2\u0000\u0391\u0392\u0005X\u0000"+ - "\u0000\u0392\u0394\u0003\u0210\u0108\u0000\u0393\u0391\u0001\u0000\u0000"+ - "\u0000\u0393\u0394\u0001\u0000\u0000\u0000\u0394\u041a\u0001\u0000\u0000"+ - "\u0000\u0395\u0397\u0005\u0013\u0000\u0000\u0396\u0398\u0005^\u0000\u0000"+ - "\u0397\u0396\u0001\u0000\u0000\u0000\u0397\u0398\u0001\u0000\u0000\u0000"+ - "\u0398\u0399\u0001\u0000\u0000\u0000\u0399\u039a\u0003\u0218\u010c\u0000"+ - "\u039a\u039b\u0005\u0207\u0000\u0000\u039b\u039c\u0005\u009b\u0000\u0000"+ - "\u039c\u039d\u0003\u01b8\u00dc\u0000\u039d\u041a\u0001\u0000\u0000\u0000"+ - "\u039e\u03a0\u0005\u0013\u0000\u0000\u039f\u03a1\u0005^\u0000\u0000\u03a0"+ - "\u039f\u0001\u0000\u0000\u0000\u03a0\u03a1\u0001\u0000\u0000\u0000\u03a1"+ - "\u03a2\u0001\u0000\u0000\u0000\u03a2\u03a3\u0003\u0218\u010c\u0000\u03a3"+ - "\u03a4\u0005\u00bc\u0000\u0000\u03a4\u03a5\u0005\u009b\u0000\u0000\u03a5"+ - "\u041a\u0001\u0000\u0000\u0000\u03a6\u03a8\u0005\u0013\u0000\u0000\u03a7"+ - "\u03a9\u0005^\u0000\u0000\u03a8\u03a7\u0001\u0000\u0000\u0000\u03a8\u03a9"+ - "\u0001\u0000\u0000\u0000\u03a9\u03aa\u0001\u0000\u0000\u0000\u03aa\u03ab"+ - "\u0003\u0218\u010c\u0000\u03ab\u03ac\u0007\u0000\u0000\u0000\u03ac\u03ad"+ - "\u0005\u016d\u0000\u0000\u03ad\u03ae\u0005\u0172\u0000\u0000\u03ae\u041a"+ - "\u0001\u0000\u0000\u0000\u03af\u03b1\u0005\u0013\u0000\u0000\u03b0\u03b2"+ - "\u0005^\u0000\u0000\u03b1\u03b0\u0001\u0000\u0000\u0000\u03b1\u03b2\u0001"+ - "\u0000\u0000\u0000\u03b2\u03b3\u0001\u0000\u0000\u0000\u03b3\u03b4\u0003"+ - "\u0218\u010c\u0000\u03b4\u03b5\u0005\u0207\u0000\u0000\u03b5\u03b6\u0005"+ - "\u0224\u0000\u0000\u03b6\u03b7\u0005\u011b\u0000\u0000\u03b7\u041a\u0001"+ - "\u0000\u0000\u0000\u03b8\u03ba\u0005\u0013\u0000\u0000\u03b9\u03bb\u0005"+ - "^\u0000\u0000\u03ba\u03b9\u0001\u0000\u0000\u0000\u03ba\u03bb\u0001\u0000"+ - "\u0000\u0000\u03bb\u03bc\u0001\u0000\u0000\u0000\u03bc\u03bd\u0003\u0218"+ - "\u010c\u0000\u03bd\u03be\u0005\u0207\u0000\u0000\u03be\u03bf\u0005\u0300"+ - "\u0000\u0000\u03bf\u03c0\u0003\u01e0\u00f0\u0000\u03c0\u03c1\u0005\u0301"+ - "\u0000\u0000\u03c1\u041a\u0001\u0000\u0000\u0000\u03c2\u03c4\u0005\u0013"+ - "\u0000\u0000\u03c3\u03c5\u0005^\u0000\u0000\u03c4\u03c3\u0001\u0000\u0000"+ - "\u0000\u03c4\u03c5\u0001\u0000\u0000\u0000\u03c5\u03c6\u0001\u0000\u0000"+ - "\u0000\u03c6\u03c7\u0003\u0218\u010c\u0000\u03c7\u03c8\u0005\u01d8\u0000"+ - "\u0000\u03c8\u03c9\u0005\u0300\u0000\u0000\u03c9\u03ca\u0003\u01dc\u00ee"+ - "\u0000\u03ca\u03cb\u0005\u0301\u0000\u0000\u03cb\u041a\u0001\u0000\u0000"+ - "\u0000\u03cc\u03ce\u0005\u0013\u0000\u0000\u03cd\u03cf\u0005^\u0000\u0000"+ - "\u03ce\u03cd\u0001\u0000\u0000\u0000\u03ce\u03cf\u0001\u0000\u0000\u0000"+ - "\u03cf\u03d0\u0001\u0000\u0000\u0000\u03d0\u03d1\u0003\u0218\u010c\u0000"+ - "\u03d1\u03d2\u0005\u0207\u0000\u0000\u03d2\u03d3\u0005\u0229\u0000\u0000"+ - "\u03d3\u03d4\u0007\u0003\u0000\u0000\u03d4\u041a\u0001\u0000\u0000\u0000"+ - "\u03d5\u03d7\u0005\u0013\u0000\u0000\u03d6\u03d8\u0005^\u0000\u0000\u03d7"+ - "\u03d6\u0001\u0000\u0000\u0000\u03d7\u03d8\u0001\u0000\u0000\u0000\u03d8"+ - "\u03d9\u0001\u0000\u0000\u0000\u03d9\u03da\u0003\u0218\u010c\u0000\u03da"+ - "\u03dc\u0005\u0186\u0000\u0000\u03db\u03dd\u0007\u0004\u0000\u0000\u03dc"+ - "\u03db\u0001\u0000\u0000\u0000\u03dc\u03dd\u0001\u0000\u0000\u0000\u03dd"+ - "\u041a\u0001\u0000\u0000\u0000\u03de\u03df\u0005\u000b\u0000\u0000\u03df"+ - "\u03e2\u0003\u0204\u0102\u0000\u03e0\u03e1\u0005\u016d\u0000\u0000\u03e1"+ - "\u03e3\u0005\u0275\u0000\u0000\u03e2\u03e0\u0001\u0000\u0000\u0000\u03e2"+ - "\u03e3\u0001\u0000\u0000\u0000\u03e3\u041a\u0001\u0000\u0000\u0000\u03e4"+ - "\u03e5\u0005\u0276\u0000\u0000\u03e5\u03e6\u0005m\u0000\u0000\u03e6\u041a"+ - "\u0003\u0212\u0109\u0000\u03e7\u03e8\u0005\u00bc\u0000\u0000\u03e8\u03eb"+ - "\u0005m\u0000\u0000\u03e9\u03ea\u0005\u02b4\u0000\u0000\u03ea\u03ec\u0005"+ - "\u00d3\u0000\u0000\u03eb\u03e9\u0001\u0000\u0000\u0000\u03eb\u03ec\u0001"+ - "\u0000\u0000\u0000\u03ec\u03ed\u0001\u0000\u0000\u0000\u03ed\u03ef\u0003"+ - "\u0212\u0109\u0000\u03ee\u03f0\u0007\u0001\u0000\u0000\u03ef\u03ee\u0001"+ - "\u0000\u0000\u0000\u03ef\u03f0\u0001\u0000\u0000\u0000\u03f0\u041a\u0001"+ - "\u0000\u0000\u0000\u03f1\u03f2\u0005\u00b3\u0000\u0000\u03f2\u03f6\u0005"+ - "\u0255\u0000\u0000\u03f3\u03f7\u0003\u0212\u0109\u0000\u03f4\u03f7\u0005"+ - "\u0010\u0000\u0000\u03f5\u03f7\u0005\u026e\u0000\u0000\u03f6\u03f3\u0001"+ - "\u0000\u0000\u0000\u03f6\u03f4\u0001\u0000\u0000\u0000\u03f6\u03f5\u0001"+ - "\u0000\u0000\u0000\u03f6\u03f7\u0001\u0000\u0000\u0000\u03f7\u041a\u0001"+ - "\u0000\u0000\u0000\u03f8\u03f9\u0005\u00c3\u0000\u0000\u03f9\u03fd\u0005"+ - "\u0255\u0000\u0000\u03fa\u03fe\u0003\u0212\u0109\u0000\u03fb\u03fe\u0005"+ - "\u0010\u0000\u0000\u03fc\u03fe\u0005\u026e\u0000\u0000\u03fd\u03fa\u0001"+ - "\u0000\u0000\u0000\u03fd\u03fb\u0001\u0000\u0000\u0000\u03fd\u03fc\u0001"+ - "\u0000\u0000\u0000\u03fd\u03fe\u0001\u0000\u0000\u0000\u03fe\u041a\u0001"+ - "\u0000\u0000\u0000\u03ff\u0400\u0005\u00c3\u0000\u0000\u0400\u0401\u0005"+ - "\u01d7\u0000\u0000\u0401\u0402\u0005\u0255\u0000\u0000\u0402\u041a\u0003"+ - "\u0212\u0109\u0000\u0403\u0404\u0005\u00c3\u0000\u0000\u0404\u0405\u0005"+ - "\u0014\u0000\u0000\u0405\u0406\u0005\u0255\u0000\u0000\u0406\u041a\u0003"+ - "\u0212\u0109\u0000\u0407\u0408\u0005\u0207\u0000\u0000\u0408\u0409\u0005"+ - "\u0288\u0000\u0000\u0409\u041a\u0005\u017e\u0000\u0000\u040a\u040b\u0005"+ - "\u0207\u0000\u0000\u040b\u040c\u0005\u028a\u0000\u0000\u040c\u041a\u0005"+ - "\u017e\u0000\u0000\u040d\u040e\u0005\u0295\u0000\u0000\u040e\u041a\u0003"+ - "\u0210\u0108\u0000\u040f\u0410\u0005\u0167\u0000\u0000\u0410\u0411\u0005"+ - "\u0295\u0000\u0000\u0411\u041a\u0003\u0210\u0108\u0000\u0412\u0413\u0005"+ - "\u0193\u0000\u0000\u0413\u0414\u0005\u0247\u0000\u0000\u0414\u041a\u0003"+ - "\u0206\u0103\u0000\u0415\u0417\u0005\u0186\u0000\u0000\u0416\u0418\u0007"+ - "\u0004\u0000\u0000\u0417\u0416\u0001\u0000\u0000\u0000\u0417\u0418\u0001"+ - "\u0000\u0000\u0000\u0418\u041a\u0001\u0000\u0000\u0000\u0419\u036d\u0001"+ - "\u0000\u0000\u0000\u0419\u037a\u0001\u0000\u0000\u0000\u0419\u0386\u0001"+ - "\u0000\u0000\u0000\u0419\u0395\u0001\u0000\u0000\u0000\u0419\u039e\u0001"+ - "\u0000\u0000\u0000\u0419\u03a6\u0001\u0000\u0000\u0000\u0419\u03af\u0001"+ - "\u0000\u0000\u0000\u0419\u03b8\u0001\u0000\u0000\u0000\u0419\u03c2\u0001"+ - "\u0000\u0000\u0000\u0419\u03cc\u0001\u0000\u0000\u0000\u0419\u03d5\u0001"+ - "\u0000\u0000\u0000\u0419\u03de\u0001\u0000\u0000\u0000\u0419\u03e4\u0001"+ - "\u0000\u0000\u0000\u0419\u03e7\u0001\u0000\u0000\u0000\u0419\u03f1\u0001"+ - "\u0000\u0000\u0000\u0419\u03f8\u0001\u0000\u0000\u0000\u0419\u03ff\u0001"+ - "\u0000\u0000\u0000\u0419\u0403\u0001\u0000\u0000\u0000\u0419\u0407\u0001"+ - "\u0000\u0000\u0000\u0419\u040a\u0001\u0000\u0000\u0000\u0419\u040d\u0001"+ - "\u0000\u0000\u0000\u0419\u040f\u0001\u0000\u0000\u0000\u0419\u0412\u0001"+ - "\u0000\u0000\u0000\u0419\u0415\u0001\u0000\u0000\u0000\u041a\u001b\u0001"+ - "\u0000\u0000\u0000\u041b\u0420\u0003\u001a\r\u0000\u041c\u041d\u0005\u02fa"+ - "\u0000\u0000\u041d\u041f\u0003\u001a\r\u0000\u041e\u041c\u0001\u0000\u0000"+ - "\u0000\u041f\u0422\u0001\u0000\u0000\u0000\u0420\u041e\u0001\u0000\u0000"+ - "\u0000\u0420\u0421\u0001\u0000\u0000\u0000\u0421\u001d\u0001\u0000\u0000"+ - "\u0000\u0422\u0420\u0001\u0000\u0000\u0000\u0423\u0424\u0005\u0013\u0000"+ - "\u0000\u0424\u0425\u0005\u00e5\u0000\u0000\u0425\u0428\u0005\u0237\u0000"+ - "\u0000\u0426\u0427\u0005\u02b4\u0000\u0000\u0427\u0429\u0005\u00d3\u0000"+ - "\u0000\u0428\u0426\u0001\u0000\u0000\u0000\u0428\u0429\u0001\u0000\u0000"+ - "\u0000\u0429\u042b\u0001\u0000\u0000\u0000\u042a\u042c\u0005\u0181\u0000"+ - "\u0000\u042b\u042a\u0001\u0000\u0000\u0000\u042b\u042c\u0001\u0000\u0000"+ - "\u0000\u042c\u042d\u0001\u0000\u0000\u0000\u042d\u042f\u0003\u0210\u0108"+ - "\u0000\u042e\u0430\u0005\u02ff\u0000\u0000\u042f\u042e\u0001\u0000\u0000"+ - "\u0000\u042f\u0430\u0001\u0000\u0000\u0000\u0430\u0431\u0001\u0000\u0000"+ - "\u0000\u0431\u0432\u0003\u001c\u000e\u0000\u0432\u0462\u0001\u0000\u0000"+ - "\u0000\u0433\u0434\u0005\u0013\u0000\u0000\u0434\u0435\u0005\u00e5\u0000"+ - "\u0000\u0435\u0438\u0005\u0237\u0000\u0000\u0436\u0437\u0005\u02b4\u0000"+ - "\u0000\u0437\u0439\u0005\u00d3\u0000\u0000\u0438\u0436\u0001\u0000\u0000"+ - "\u0000\u0438\u0439\u0001\u0000\u0000\u0000\u0439\u043b\u0001\u0000\u0000"+ - "\u0000\u043a\u043c\u0005\u0181\u0000\u0000\u043b\u043a\u0001\u0000\u0000"+ - "\u0000\u043b\u043c\u0001\u0000\u0000\u0000\u043c\u043d\u0001\u0000\u0000"+ - "\u0000\u043d\u043f\u0003\u0210\u0108\u0000\u043e\u0440\u0005\u02ff\u0000"+ - "\u0000\u043f\u043e\u0001\u0000\u0000\u0000\u043f\u0440\u0001\u0000\u0000"+ - "\u0000\u0440\u0441\u0001\u0000\u0000\u0000\u0441\u0443\u0005\u01d4\u0000"+ - "\u0000\u0442\u0444\u0005^\u0000\u0000\u0443\u0442\u0001\u0000\u0000\u0000"+ - "\u0443\u0444\u0001\u0000\u0000\u0000\u0444\u0445\u0001\u0000\u0000\u0000"+ - "\u0445\u0446\u0003\u0218\u010c\u0000\u0446\u0447\u0005\u0247\u0000\u0000"+ - "\u0447\u0448\u0003\u0210\u0108\u0000\u0448\u0462\u0001\u0000\u0000\u0000"+ - "\u0449\u044a\u0005\u0013\u0000\u0000\u044a\u044b\u0005\u00e5\u0000\u0000"+ - "\u044b\u044e\u0005\u0237\u0000\u0000\u044c\u044d\u0005\u02b4\u0000\u0000"+ - "\u044d\u044f\u0005\u00d3\u0000\u0000\u044e\u044c\u0001\u0000\u0000\u0000"+ - "\u044e\u044f\u0001\u0000\u0000\u0000\u044f\u0450\u0001\u0000\u0000\u0000"+ - "\u0450\u0451\u0003\u0210\u0108\u0000\u0451\u0452\u0005\u01d4\u0000\u0000"+ - "\u0452\u0453\u0005\u0247\u0000\u0000\u0453\u0454\u0003\u0210\u0108\u0000"+ - "\u0454\u0462\u0001\u0000\u0000\u0000\u0455\u0456\u0005\u0013\u0000\u0000"+ - "\u0456\u0457\u0005\u00e5\u0000\u0000\u0457\u045a\u0005\u0237\u0000\u0000"+ - "\u0458\u0459\u0005\u02b4\u0000\u0000\u0459\u045b\u0005\u00d3\u0000\u0000"+ - "\u045a\u0458\u0001\u0000\u0000\u0000\u045a\u045b\u0001\u0000\u0000\u0000"+ - "\u045b\u045c\u0001\u0000\u0000\u0000\u045c\u045d\u0003\u0210\u0108\u0000"+ - "\u045d\u045e\u0005\u0207\u0000\u0000\u045e\u045f\u0005\u01f3\u0000\u0000"+ - "\u045f\u0460\u0003\u0210\u0108\u0000\u0460\u0462\u0001\u0000\u0000\u0000"+ - "\u0461\u0423\u0001\u0000\u0000\u0000\u0461\u0433\u0001\u0000\u0000\u0000"+ - "\u0461\u0449\u0001\u0000\u0000\u0000\u0461\u0455\u0001\u0000\u0000\u0000"+ - "\u0462\u001f\u0001\u0000\u0000\u0000\u0463\u0464\u0003\u0214\u010a\u0000"+ - "\u0464!\u0001\u0000\u0000\u0000\u0465\u0466\u0005\u0013\u0000\u0000\u0466"+ - "\u0467\u0005\u00fa\u0000\u0000\u0467\u0468\u0003\u0206\u0103\u0000\u0468"+ - "\u0469\u0005\u000b\u0000\u0000\u0469\u046a\u0005\u026e\u0000\u0000\u046a"+ - "\u046b\u0003\u01dc\u00ee\u0000\u046b\u047b\u0001\u0000\u0000\u0000\u046c"+ - "\u046d\u0005\u0013\u0000\u0000\u046d\u046e\u0005\u00fa\u0000\u0000\u046e"+ - "\u046f\u0003\u0206\u0103\u0000\u046f\u0470\u0005\u00bc\u0000\u0000\u0470"+ - "\u0471\u0005\u026e\u0000\u0000\u0471\u0472\u0003\u01dc\u00ee\u0000\u0472"+ - "\u047b\u0001\u0000\u0000\u0000\u0473\u0474\u0005\u0013\u0000\u0000\u0474"+ - "\u0475\u0005\u00fa\u0000\u0000\u0475\u0476\u0003\u0210\u0108\u0000\u0476"+ - "\u0477\u0005\u01d4\u0000\u0000\u0477\u0478\u0005\u0247\u0000\u0000\u0478"+ - "\u0479\u0003\u0210\u0108\u0000\u0479\u047b\u0001\u0000\u0000\u0000\u047a"+ - "\u0465\u0001\u0000\u0000\u0000\u047a\u046c\u0001\u0000\u0000\u0000\u047a"+ - "\u0473\u0001\u0000\u0000\u0000\u047b#\u0001\u0000\u0000\u0000\u047c\u047d"+ - "\u0005\u0013\u0000\u0000\u047d\u0480\u0005\u010c\u0000\u0000\u047e\u047f"+ - "\u0005\u02b4\u0000\u0000\u047f\u0481\u0005\u00d3\u0000\u0000\u0480\u047e"+ - "\u0001\u0000\u0000\u0000\u0480\u0481\u0001\u0000\u0000\u0000\u0481\u0482"+ - "\u0001\u0000\u0000\u0000\u0482\u0483\u0003\u0210\u0108\u0000\u0483\u0484"+ - "\u0005\u01d4\u0000\u0000\u0484\u0485\u0005\u0247\u0000\u0000\u0485\u0486"+ - "\u0003\u0210\u0108\u0000\u0486\u04c3\u0001\u0000\u0000\u0000\u0487\u0488"+ - "\u0005\u0013\u0000\u0000\u0488\u048b\u0005\u010c\u0000\u0000\u0489\u048a"+ - "\u0005\u02b4\u0000\u0000\u048a\u048c\u0005\u00d3\u0000\u0000\u048b\u0489"+ - "\u0001\u0000\u0000\u0000\u048b\u048c\u0001\u0000\u0000\u0000\u048c\u048d"+ - "\u0001\u0000\u0000\u0000\u048d\u048e\u0003\u0210\u0108\u0000\u048e\u048f"+ - "\u0005\u0207\u0000\u0000\u048f\u0490\u0005\u023a\u0000\u0000\u0490\u0491"+ - "\u0003\u0210\u0108\u0000\u0491\u04c3\u0001\u0000\u0000\u0000\u0492\u0493"+ - "\u0005\u0013\u0000\u0000\u0493\u0494\u0005\u010c\u0000\u0000\u0494\u0495"+ - "\u0003\u0210\u0108\u0000\u0495\u0496\u0005\u00a7\u0000\u0000\u0496\u0497"+ - "\u0005\u0180\u0000\u0000\u0497\u0498\u0005\u00d7\u0000\u0000\u0498\u0499"+ - "\u0003\u0210\u0108\u0000\u0499\u04c3\u0001\u0000\u0000\u0000\u049a\u049b"+ - "\u0005\u0013\u0000\u0000\u049b\u049e\u0005\u010c\u0000\u0000\u049c\u049d"+ - "\u0005\u02b4\u0000\u0000\u049d\u049f\u0005\u00d3\u0000\u0000\u049e\u049c"+ - "\u0001\u0000\u0000\u0000\u049e\u049f\u0001\u0000\u0000\u0000\u049f\u04a0"+ - "\u0001\u0000\u0000\u0000\u04a0\u04a1\u0003\u0210\u0108\u0000\u04a1\u04a2"+ - "\u0005\u0207\u0000\u0000\u04a2\u04a3\u0005\u0300\u0000\u0000\u04a3\u04a4"+ - "\u0003\u01e0\u00f0\u0000\u04a4\u04a5\u0005\u0301\u0000\u0000\u04a5\u04c3"+ - "\u0001\u0000\u0000\u0000\u04a6\u04a7\u0005\u0013\u0000\u0000\u04a7\u04aa"+ - "\u0005\u010c\u0000\u0000\u04a8\u04a9\u0005\u02b4\u0000\u0000\u04a9\u04ab"+ - "\u0005\u00d3\u0000\u0000\u04aa\u04a8\u0001\u0000\u0000\u0000\u04aa\u04ab"+ - "\u0001\u0000\u0000\u0000\u04ab\u04ac\u0001\u0000\u0000\u0000\u04ac\u04ad"+ - "\u0005\u01d8\u0000\u0000\u04ad\u04ae\u0005\u0300\u0000\u0000\u04ae\u04af"+ - "\u0003\u01dc\u00ee\u0000\u04af\u04b0\u0005\u0301\u0000\u0000\u04b0\u04c3"+ - "\u0001\u0000\u0000\u0000\u04b1\u04b2\u0005\u0013\u0000\u0000\u04b2\u04b3"+ - "\u0005\u010c\u0000\u0000\u04b3\u04b4\u0005\u0010\u0000\u0000\u04b4\u04b5"+ - "\u0005\u0109\u0000\u0000\u04b5\u04b6\u0005\u023a\u0000\u0000\u04b6\u04ba"+ - "\u0003\u0210\u0108\u0000\u04b7\u04b8\u0005\u02d0\u0000\u0000\u04b8\u04b9"+ - "\u00056\u0000\u0000\u04b9\u04bb\u0003\u01dc\u00ee\u0000\u04ba\u04b7\u0001"+ - "\u0000\u0000\u0000\u04ba\u04bb\u0001\u0000\u0000\u0000\u04bb\u04bc\u0001"+ - "\u0000\u0000\u0000\u04bc\u04bd\u0005\u0207\u0000\u0000\u04bd\u04be\u0005"+ - "\u023a\u0000\u0000\u04be\u04c0\u0003\u0210\u0108\u0000\u04bf\u04c1\u0005"+ - "\u0171\u0000\u0000\u04c0\u04bf\u0001\u0000\u0000\u0000\u04c0\u04c1\u0001"+ - "\u0000\u0000\u0000\u04c1\u04c3\u0001\u0000\u0000\u0000\u04c2\u047c\u0001"+ - "\u0000\u0000\u0000\u04c2\u0487\u0001\u0000\u0000\u0000\u04c2\u0492\u0001"+ - "\u0000\u0000\u0000\u04c2\u049a\u0001\u0000\u0000\u0000\u04c2\u04a6\u0001"+ - "\u0000\u0000\u0000\u04c2\u04b1\u0001\u0000\u0000\u0000\u04c3%\u0001\u0000"+ - "\u0000\u0000\u04c4\u04c6\u0005\u0013\u0000\u0000\u04c5\u04c7\u0005\u01b7"+ - "\u0000\u0000\u04c6\u04c5\u0001\u0000\u0000\u0000\u04c6\u04c7\u0001\u0000"+ - "\u0000\u0000\u04c7\u04c8\u0001\u0000\u0000\u0000\u04c8\u04c9\u0005\u012b"+ - "\u0000\u0000\u04c9\u04ca\u0003\u0210\u0108\u0000\u04ca\u04cb\u0005\u01d4"+ - "\u0000\u0000\u04cb\u04cc\u0005\u0247\u0000\u0000\u04cc\u04cd\u0003\u0210"+ - "\u0108\u0000\u04cd\u04dc\u0001\u0000\u0000\u0000\u04ce\u04d0\u0005\u0013"+ - "\u0000\u0000\u04cf\u04d1\u0005\u01b7\u0000\u0000\u04d0\u04cf\u0001\u0000"+ - "\u0000\u0000\u04d0\u04d1\u0001\u0000\u0000\u0000\u04d1\u04d2\u0001\u0000"+ - "\u0000\u0000\u04d2\u04d3\u0005\u012b\u0000\u0000\u04d3\u04d4\u0003\u0210"+ - "\u0108\u0000\u04d4\u04d5\u0005\u0193\u0000\u0000\u04d5\u04d9\u0005\u0247"+ - "\u0000\u0000\u04d6\u04da\u0003\u0210\u0108\u0000\u04d7\u04da\u0005\u008d"+ - "\u0000\u0000\u04d8\u04da\u0005\u0206\u0000\u0000\u04d9\u04d6\u0001\u0000"+ - "\u0000\u0000\u04d9\u04d7\u0001\u0000\u0000\u0000\u04d9\u04d8\u0001\u0000"+ - "\u0000\u0000\u04da\u04dc\u0001\u0000\u0000\u0000\u04db\u04c4\u0001\u0000"+ - "\u0000\u0000\u04db\u04ce\u0001\u0000\u0000\u0000\u04dc\'\u0001\u0000\u0000"+ - "\u0000\u04dd\u04de\u0005\u0013\u0000\u0000\u04de\u04df\u0005\u012c\u0000"+ - "\u0000\u04df\u04e0\u0005\u0178\u0000\u0000\u04e0\u04e1\u0005\u0307\u0000"+ - "\u0000\u04e1\u04e2\u0005\u0193\u0000\u0000\u04e2\u04e6\u0005\u0247\u0000"+ - "\u0000\u04e3\u04e7\u0003\u0210\u0108\u0000\u04e4\u04e7\u0005\u008d\u0000"+ - "\u0000\u04e5\u04e7\u0005\u0206\u0000\u0000\u04e6\u04e3\u0001\u0000\u0000"+ - "\u0000\u04e6\u04e4\u0001\u0000\u0000\u0000\u04e6\u04e5\u0001\u0000\u0000"+ - "\u0000\u04e7)\u0001\u0000\u0000\u0000\u04e8\u04e9\u0003\u0214\u010a\u0000"+ - "\u04e9+\u0001\u0000\u0000\u0000\u04ea\u04eb\u0003\u0214\u010a\u0000\u04eb"+ - "-\u0001\u0000\u0000\u0000\u04ec\u04ed\u0005\u0013\u0000\u0000\u04ed\u04ee"+ - "\u0005\u0184\u0000\u0000\u04ee\u04ef\u0005Q\u0000\u0000\u04ef\u04f0\u0003"+ - "\u0210\u0108\u0000\u04f0\u04f1\u0005\u0273\u0000\u0000\u04f1\u04f2\u0003"+ - "\u01e8\u00f4\u0000\u04f2\u04f3\u0005\u01d4\u0000\u0000\u04f3\u04f4\u0005"+ - "\u0247\u0000\u0000\u04f4\u04f5\u0003\u0210\u0108\u0000\u04f5\u050e\u0001"+ - "\u0000\u0000\u0000\u04f6\u04f7\u0005\u0013\u0000\u0000\u04f7\u04f8\u0005"+ - "\u0184\u0000\u0000\u04f8\u04f9\u0005Q\u0000\u0000\u04f9\u04fa\u0003\u0210"+ - "\u0108\u0000\u04fa\u04fb\u0005\u0273\u0000\u0000\u04fb\u04fc\u0003\u01e8"+ - "\u00f4\u0000\u04fc\u04fd\u0005\u0193\u0000\u0000\u04fd\u0501\u0005\u0247"+ - "\u0000\u0000\u04fe\u0502\u0003\u0210\u0108\u0000\u04ff\u0502\u0005\u008d"+ - "\u0000\u0000\u0500\u0502\u0005\u0206\u0000\u0000\u0501\u04fe\u0001\u0000"+ - "\u0000\u0000\u0501\u04ff\u0001\u0000\u0000\u0000\u0501\u0500\u0001\u0000"+ - "\u0000\u0000\u0502\u050e\u0001\u0000\u0000\u0000\u0503\u0504\u0005\u0013"+ - "\u0000\u0000\u0504\u0505\u0005\u0184\u0000\u0000\u0505\u0506\u0005Q\u0000"+ - "\u0000\u0506\u0507\u0003\u0210\u0108\u0000\u0507\u0508\u0005\u0273\u0000"+ - "\u0000\u0508\u0509\u0003\u01e8\u00f4\u0000\u0509\u050a\u0005\u0207\u0000"+ - "\u0000\u050a\u050b\u0005\u01f3\u0000\u0000\u050b\u050c\u0003\u0210\u0108"+ - "\u0000\u050c\u050e\u0001\u0000\u0000\u0000\u050d\u04ec\u0001\u0000\u0000"+ - "\u0000\u050d\u04f6\u0001\u0000\u0000\u0000\u050d\u0503\u0001\u0000\u0000"+ - "\u0000\u050e/\u0001\u0000\u0000\u0000\u050f\u0510\u0003\u0214\u010a\u0000"+ - "\u05101\u0001\u0000\u0000\u0000\u0511\u0512\u0005\u0013\u0000\u0000\u0512"+ - "\u0513\u0005\u02cf\u0000\u0000\u0513\u0514\u0003\u0210\u0108\u0000\u0514"+ - "\u0515\u0005\u0180\u0000\u0000\u0515\u0516\u0003\u0210\u0108\u0000\u0516"+ - "\u0517\u0005\u01d4\u0000\u0000\u0517\u0518\u0005\u0247\u0000\u0000\u0518"+ - "\u0519\u0003\u0210\u0108\u0000\u0519\u052d\u0001\u0000\u0000\u0000\u051a"+ - "\u051b\u0005\u0013\u0000\u0000\u051b\u051c\u0005\u02cf\u0000\u0000\u051c"+ - "\u051d\u0003\u0210\u0108\u0000\u051d\u051e\u0005\u0180\u0000\u0000\u051e"+ - "\u0521\u0003\u0210\u0108\u0000\u051f\u0520\u0005\u0247\u0000\u0000\u0520"+ - "\u0522\u0003\u0208\u0104\u0000\u0521\u051f\u0001\u0000\u0000\u0000\u0521"+ - "\u0522\u0001\u0000\u0000\u0000\u0522\u0525\u0001\u0000\u0000\u0000\u0523"+ - "\u0524\u0005\u0273\u0000\u0000\u0524\u0526\u0003\u01f8\u00fc\u0000\u0525"+ - "\u0523\u0001\u0000\u0000\u0000\u0525\u0526\u0001\u0000\u0000\u0000\u0526"+ - "\u052a\u0001\u0000\u0000\u0000\u0527\u0528\u0005\u0288\u0000\u0000\u0528"+ - "\u0529\u0005N\u0000\u0000\u0529\u052b\u0003\u01f8\u00fc\u0000\u052a\u0527"+ - "\u0001\u0000\u0000\u0000\u052a\u052b\u0001\u0000\u0000\u0000\u052b\u052d"+ - "\u0001\u0000\u0000\u0000\u052c\u0511\u0001\u0000\u0000\u0000\u052c\u051a"+ - "\u0001\u0000\u0000\u0000\u052d3\u0001\u0000\u0000\u0000\u052e\u052f\u0005"+ - "\u0013\u0000\u0000\u052f\u0530\u0005\u01ba\u0000\u0000\u0530\u0531\u0003"+ - "\u0210\u0108\u0000\u0531\u0532\u0005\u000b\u0000\u0000\u0532\u0534\u0005"+ - "\u0237\u0000\u0000\u0533\u0535\u0005\u0181\u0000\u0000\u0534\u0533\u0001"+ - "\u0000\u0000\u0000\u0534\u0535\u0001\u0000\u0000\u0000\u0535\u0536\u0001"+ - "\u0000\u0000\u0000\u0536\u0537\u0003\u01dc\u00ee\u0000\u0537\u0563\u0001"+ - "\u0000\u0000\u0000\u0538\u0539\u0005\u0013\u0000\u0000\u0539\u053a\u0005"+ - "\u01ba\u0000\u0000\u053a\u053b\u0003\u0210\u0108\u0000\u053b\u053c\u0005"+ - "\u0207\u0000\u0000\u053c\u053e\u0005\u0237\u0000\u0000\u053d\u053f\u0005"+ - "\u0181\u0000\u0000\u053e\u053d\u0001\u0000\u0000\u0000\u053e\u053f\u0001"+ - "\u0000\u0000\u0000\u053f\u0540\u0001\u0000\u0000\u0000\u0540\u0541\u0003"+ - "\u01dc\u00ee\u0000\u0541\u0563\u0001\u0000\u0000\u0000\u0542\u0543\u0005"+ - "\u0013\u0000\u0000\u0543\u0544\u0005\u01ba\u0000\u0000\u0544\u0545\u0003"+ - "\u0210\u0108\u0000\u0545\u0546\u0005\u00bc\u0000\u0000\u0546\u0548\u0005"+ - "\u0237\u0000\u0000\u0547\u0549\u0005\u0181\u0000\u0000\u0548\u0547\u0001"+ - "\u0000\u0000\u0000\u0548\u0549\u0001\u0000\u0000\u0000\u0549\u054a\u0001"+ - "\u0000\u0000\u0000\u054a\u054b\u0003\u01dc\u00ee\u0000\u054b\u0563\u0001"+ - "\u0000\u0000\u0000\u054c\u054d\u0005\u0013\u0000\u0000\u054d\u054e\u0005"+ - "\u01ba\u0000\u0000\u054e\u054f\u0003\u0210\u0108\u0000\u054f\u0550\u0005"+ - "\u0207\u0000\u0000\u0550\u0551\u0005\u0300\u0000\u0000\u0551\u0552\u0003"+ - "\u01e0\u00f0\u0000\u0552\u0553\u0005\u0301\u0000\u0000\u0553\u0563\u0001"+ - "\u0000\u0000\u0000\u0554\u0555\u0005\u0013\u0000\u0000\u0555\u0556\u0005"+ - "\u01ba\u0000\u0000\u0556\u0557\u0003\u0210\u0108\u0000\u0557\u0558\u0005"+ - "\u0193\u0000\u0000\u0558\u0559\u0005\u0247\u0000\u0000\u0559\u055a\u0003"+ - "\u0206\u0103\u0000\u055a\u0563\u0001\u0000\u0000\u0000\u055b\u055c\u0005"+ - "\u0013\u0000\u0000\u055c\u055d\u0005\u01ba\u0000\u0000\u055d\u055e\u0003"+ - "\u0210\u0108\u0000\u055e\u055f\u0005\u01d4\u0000\u0000\u055f\u0560\u0005"+ - "\u0247\u0000\u0000\u0560\u0561\u0003\u01d8\u00ec\u0000\u0561\u0563\u0001"+ - "\u0000\u0000\u0000\u0562\u052e\u0001\u0000\u0000\u0000\u0562\u0538\u0001"+ - "\u0000\u0000\u0000\u0562\u0542\u0001\u0000\u0000\u0000\u0562\u054c\u0001"+ - "\u0000\u0000\u0000\u0562\u0554\u0001\u0000\u0000\u0000\u0562\u055b\u0001"+ - "\u0000\u0000\u0000\u05635\u0001\u0000\u0000\u0000\u0564\u057e\u0005\u0291"+ - "\u0000\u0000\u0565\u057e\u0005\u0292\u0000\u0000\u0566\u057e\u0005\u007f"+ - "\u0000\u0000\u0567\u057e\u0005\u0168\u0000\u0000\u0568\u057e\u0005\u0293"+ - "\u0000\u0000\u0569\u057e\u0005\u0294\u0000\u0000\u056a\u057e\u0005\u0295"+ - "\u0000\u0000\u056b\u057e\u0005\u0296\u0000\u0000\u056c\u057e\u0005\u0297"+ - "\u0000\u0000\u056d\u057e\u0005\u0298\u0000\u0000\u056e\u057e\u0005\u0299"+ - "\u0000\u0000\u056f\u057e\u0005\u029a\u0000\u0000\u0570\u057e\u0005\u029b"+ - "\u0000\u0000\u0571\u057e\u0005\u029c\u0000\u0000\u0572\u0573\u0005k\u0000"+ - "\u0000\u0573\u0574\u0005\u0136\u0000\u0000\u0574\u057e\u0005\u011b\u0000"+ - "\u0000\u0575\u0577\u0005\u00c5\u0000\u0000\u0576\u0575\u0001\u0000\u0000"+ - "\u0000\u0576\u0577\u0001\u0000\u0000\u0000\u0577\u0578\u0001\u0000\u0000"+ - "\u0000\u0578\u0579\u0005\u01a1\u0000\u0000\u0579\u057e\u0005\u030a\u0000"+ - "\u0000\u057a\u057b\u0005\u0275\u0000\u0000\u057b\u057c\u0005\u026a\u0000"+ - "\u0000\u057c\u057e\u0005\u030a\u0000\u0000\u057d\u0564\u0001\u0000\u0000"+ - "\u0000\u057d\u0565\u0001\u0000\u0000\u0000\u057d\u0566\u0001\u0000\u0000"+ - "\u0000\u057d\u0567\u0001\u0000\u0000\u0000\u057d\u0568\u0001\u0000\u0000"+ - "\u0000\u057d\u0569\u0001\u0000\u0000\u0000\u057d\u056a\u0001\u0000\u0000"+ - "\u0000\u057d\u056b\u0001\u0000\u0000\u0000\u057d\u056c\u0001\u0000\u0000"+ - "\u0000\u057d\u056d\u0001\u0000\u0000\u0000\u057d\u056e\u0001\u0000\u0000"+ - "\u0000\u057d\u056f\u0001\u0000\u0000\u0000\u057d\u0570\u0001\u0000\u0000"+ - "\u0000\u057d\u0571\u0001\u0000\u0000\u0000\u057d\u0572\u0001\u0000\u0000"+ - "\u0000\u057d\u0576\u0001\u0000\u0000\u0000\u057d\u057a\u0001\u0000\u0000"+ - "\u0000\u057e7\u0001\u0000\u0000\u0000\u057f\u0580\u0005\u0013\u0000\u0000"+ - "\u0580\u0581\u0005\u01e5\u0000\u0000\u0581\u0583\u0003\u0206\u0103\u0000"+ - "\u0582\u0584\u0005\u0288\u0000\u0000\u0583\u0582\u0001\u0000\u0000\u0000"+ - "\u0583\u0584\u0001\u0000\u0000\u0000\u0584\u0586\u0001\u0000\u0000\u0000"+ - "\u0585\u0587\u00036\u001b\u0000\u0586\u0585\u0001\u0000\u0000\u0000\u0587"+ - "\u0588\u0001\u0000\u0000\u0000\u0588\u0586\u0001\u0000\u0000\u0000\u0588"+ - "\u0589\u0001\u0000\u0000\u0000\u0589\u05ce\u0001\u0000\u0000\u0000\u058a"+ - "\u058b\u0005\u0013\u0000\u0000\u058b\u058c\u0005\u01e5\u0000\u0000\u058c"+ - "\u058d\u0003\u01d8\u00ec\u0000\u058d\u058e\u0005\u01d4\u0000\u0000\u058e"+ - "\u058f\u0005\u0247\u0000\u0000\u058f\u0590\u0003\u01d8\u00ec\u0000\u0590"+ - "\u05ce\u0001\u0000\u0000\u0000\u0591\u0592\u0005\u0013\u0000\u0000\u0592"+ - "\u0595\u0005\u01e5\u0000\u0000\u0593\u0596\u0003\u0206\u0103\u0000\u0594"+ - "\u0596\u0005\u0010\u0000\u0000\u0595\u0593\u0001\u0000\u0000\u0000\u0595"+ - "\u0594\u0001\u0000\u0000\u0000\u0596\u059a\u0001\u0000\u0000\u0000\u0597"+ - "\u0598\u0005\u0109\u0000\u0000\u0598\u0599\u0005\u0092\u0000\u0000\u0599"+ - "\u059b\u0003\u01d8\u00ec\u0000\u059a\u0597\u0001\u0000\u0000\u0000\u059a"+ - "\u059b\u0001\u0000\u0000\u0000\u059b\u059c\u0001\u0000\u0000\u0000\u059c"+ - "\u059d\u0005\u0207\u0000\u0000\u059d\u059e\u0003\u0210\u0108\u0000\u059e"+ - "\u05a1\u0007\u0005\u0000\u0000\u059f\u05a2\u0003\u020a\u0105\u0000\u05a0"+ - "\u05a2\u0005\u009b\u0000\u0000\u05a1\u059f\u0001\u0000\u0000\u0000\u05a1"+ - "\u05a0\u0001\u0000\u0000\u0000\u05a2\u05ce\u0001\u0000\u0000\u0000\u05a3"+ - "\u05a4\u0005\u0013\u0000\u0000\u05a4\u05a7\u0005\u01e5\u0000\u0000\u05a5"+ - "\u05a8\u0003\u0206\u0103\u0000\u05a6\u05a8\u0005\u0010\u0000\u0000\u05a7"+ - "\u05a5\u0001\u0000\u0000\u0000\u05a7\u05a6\u0001\u0000\u0000\u0000\u05a8"+ - "\u05ac\u0001\u0000\u0000\u0000\u05a9\u05aa\u0005\u0109\u0000\u0000\u05aa"+ - "\u05ab\u0005\u0092\u0000\u0000\u05ab\u05ad\u0003\u01d8\u00ec\u0000\u05ac"+ - "\u05a9\u0001\u0000\u0000\u0000\u05ac\u05ad\u0001\u0000\u0000\u0000\u05ad"+ - "\u05ae\u0001\u0000\u0000\u0000\u05ae\u05af\u0005\u0207\u0000\u0000\u05af"+ - "\u05b0\u0003\u0210\u0108\u0000\u05b0\u05b1\u0005\u00ec\u0000\u0000\u05b1"+ - "\u05b2\u0005\u0085\u0000\u0000\u05b2\u05ce\u0001\u0000\u0000\u0000\u05b3"+ - "\u05b4\u0005\u0013\u0000\u0000\u05b4\u05b7\u0005\u01e5\u0000\u0000\u05b5"+ - "\u05b8\u0003\u0206\u0103\u0000\u05b6\u05b8\u0005\u0010\u0000\u0000\u05b7"+ - "\u05b5\u0001\u0000\u0000\u0000\u05b7\u05b6\u0001\u0000\u0000\u0000\u05b8"+ - "\u05bc\u0001\u0000\u0000\u0000\u05b9\u05ba\u0005\u0109\u0000\u0000\u05ba"+ - "\u05bb\u0005\u0092\u0000\u0000\u05bb\u05bd\u0003\u01d8\u00ec\u0000\u05bc"+ - "\u05b9\u0001\u0000\u0000\u0000\u05bc\u05bd\u0001\u0000\u0000\u0000\u05bd"+ - "\u05be\u0001\u0000\u0000\u0000\u05be\u05bf\u0005\u01d8\u0000\u0000\u05bf"+ - "\u05ce\u0003\u0210\u0108\u0000\u05c0\u05c1\u0005\u0013\u0000\u0000\u05c1"+ - "\u05c4\u0005\u01e5\u0000\u0000\u05c2\u05c5\u0003\u0206\u0103\u0000\u05c3"+ - "\u05c5\u0005\u0010\u0000\u0000\u05c4\u05c2\u0001\u0000\u0000\u0000\u05c4"+ - "\u05c3\u0001\u0000\u0000\u0000\u05c5\u05c9\u0001\u0000\u0000\u0000\u05c6"+ - "\u05c7\u0005\u0109\u0000\u0000\u05c7\u05c8\u0005\u0092\u0000\u0000\u05c8"+ - "\u05ca\u0003\u01d8\u00ec\u0000\u05c9\u05c6\u0001\u0000\u0000\u0000\u05c9"+ - "\u05ca\u0001\u0000\u0000\u0000\u05ca\u05cb\u0001\u0000\u0000\u0000\u05cb"+ - "\u05cc\u0005\u01d8\u0000\u0000\u05cc\u05ce\u0005\u0010\u0000\u0000\u05cd"+ - "\u057f\u0001\u0000"; + "\u0001\u00fb\u0001\u00fb\u0003\u00fb\u115e\b\u00fb\u0001\u00fc\u0001\u00fc"+ + "\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc"+ + "\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc"+ + "\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0003\u00fc\u1172\b\u00fc"+ + "\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd"+ + "\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd"+ + "\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd"+ + "\u0003\u00fd\u1186\b\u00fd\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0001\u00fe"+ + "\u0001\u00fe\u0001\u00fe\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff"+ + "\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100\u0001\u0100"+ + "\u0001\u0100\u0001\u0100\u0001\u0100\u0003\u0100\u11e3\b\u0100\u0001\u0101"+ + "\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101"+ + "\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101"+ + "\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101"+ + "\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0003\u0101\u11fc\b\u0101"+ + "\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0001\u0102\u0003\u0102"+ + "\u1203\b\u0102\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103"+ + "\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103\u0001\u0103"+ + "\u0001\u0103\u0001\u0103\u0001\u0103\u0003\u0103\u1213\b\u0103\u0001\u0104"+ + "\u0001\u0104\u0001\u0105\u0001\u0105\u0001\u0105\u0005\u0105\u121a\b\u0105"+ + "\n\u0105\f\u0105\u121d\t\u0105\u0001\u0106\u0001\u0106\u0003\u0106\u1221"+ + "\b\u0106\u0001\u0107\u0001\u0107\u0004\u0107\u1225\b\u0107\u000b\u0107"+ + "\f\u0107\u1226\u0001\u0108\u0001\u0108\u0001\u0108\u0005\u0108\u122c\b"+ + "\u0108\n\u0108\f\u0108\u122f\t\u0108\u0001\u0109\u0001\u0109\u0001\u0109"+ + "\u0001\u0109\u0001\u0109\u0001\u0109\u0001\u010a\u0001\u010a\u0001\u010a"+ + "\u0001\u010a\u0001\u010a\u0003\u010a\u123c\b\u010a\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b\u0001\u010b"+ + "\u0001\u010b\u0003\u010b\u12d1\b\u010b\u0001\u010c\u0001\u010c\u0003\u010c"+ + "\u12d5\b\u010c\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d\u0001\u010d"+ + "\u0001\u010d\u0001\u010d\u0003\u010d\u1332\b\u010d\u0001\u010e\u0001\u010e"+ + "\u0001\u010e\u0003\u010e\u1337\b\u010e\u0001\u010f\u0001\u010f\u0003\u010f"+ + "\u133b\b\u010f\u0001\u0110\u0001\u0110\u0001\u0110\u0001\u0110\u0003\u0110"+ + "\u1341\b\u0110\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111\u0001\u0111"+ + "\u0001\u0111\u0003\u0111\u1385\b\u0111\u0001\u0112\u0001\u0112\u0001\u0113"+ + "\u0001\u0113\u0003\u0113\u138b\b\u0113\u0001\u0114\u0001\u0114\u0001\u0114"+ + "\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0114\u0001\u0115"+ + "\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115"+ + "\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115"+ + "\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115\u0001\u0115"+ + "\u0003\u0115\u13a8\b\u0115\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116"+ + "\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116"+ + "\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0001\u0116\u0003\u0116"+ + "\u13b9\b\u0116\u0001\u0117\u0001\u0117\u0001\u0117\u0005\u0117\u13be\b"+ + "\u0117\n\u0117\f\u0117\u13c1\t\u0117\u0001\u0118\u0001\u0118\u0001\u0118"+ + "\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118\u0001\u0118"+ + "\u0003\u0118\u13cc\b\u0118\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119\u0001\u0119"+ + "\u0003\u0119\u1408\b\u0119\u0001\u011a\u0001\u011a\u0001\u011a\u0005\u011a"+ + "\u140d\b\u011a\n\u011a\f\u011a\u1410\t\u011a\u0001\u011b\u0001\u011b\u0001"+ + "\u011b\u0003\u011b\u1415\b\u011b\u0001\u011c\u0001\u011c\u0001\u011c\u0001"+ + "\u011c\u0003\u011c\u141b\b\u011c\u0001\u011d\u0001\u011d\u0001\u011d\u0001"+ + "\u011d\u0001\u011d\u0001\u011d\u0001\u011d\u0001\u011e\u0001\u011e\u0001"+ + "\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001"+ + "\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001\u011e\u0001"+ + "\u011e\u0001\u011e\u0001\u011e\u0003\u011e\u1435\b\u011e\u0001\u011f\u0001"+ + "\u011f\u0001\u011f\u0001\u011f\u0003\u011f\u143b\b\u011f\u0001\u0120\u0001"+ + "\u0120\u0001\u0120\u0001\u0120\u0003\u0120\u1441\b\u0120\u0001\u0121\u0001"+ + "\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0121\u0001\u0122\u0005"+ + "\u0122\u144a\b\u0122\n\u0122\f\u0122\u144d\t\u0122\u0001\u0123\u0001\u0123"+ + "\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123\u0001\u0123"+ + "\u0001\u0123\u0003\u0123\u1458\b\u0123\u0001\u0124\u0001\u0124\u0001\u0124"+ + "\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124"+ + "\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124"+ + "\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124"+ + "\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124\u0001\u0124"+ + "\u0003\u0124\u1475\b\u0124\u0001\u0125\u0001\u0125\u0001\u0126\u0001\u0126"+ + "\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126"+ + "\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126"+ + "\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126"+ + "\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126"+ + "\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126\u0001\u0126"+ + "\u0001\u0126\u0001\u0126\u0001\u0126\u0003\u0126\u149c\b\u0126\u0001\u0127"+ + "\u0001\u0127\u0003\u0127\u14a0\b\u0127\u0001\u0128\u0001\u0128\u0003\u0128"+ + "\u14a4\b\u0128\u0001\u0129\u0001\u0129\u0003\u0129\u14a8\b\u0129\u0001"+ + "\u012a\u0001\u012a\u0001\u012a\u0003\u012a\u14ad\b\u012a\u0001\u012b\u0001"+ + "\u012b\u0001\u012b\u0005\u012b\u14b2\b\u012b\n\u012b\f\u012b\u14b5\t\u012b"+ + "\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c"+ + "\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0001\u012c\u0003\u012c"+ + "\u14c2\b\u012c\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d"+ + "\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d\u0001\u012d"+ + "\u0003\u012d\u14cf\b\u012d\u0001\u012e\u0001\u012e\u0001\u012e\u0001\u012e"+ + "\u0001\u012e\u0001\u012e\u0003\u012e\u14d7\b\u012e\u0001\u012f\u0001\u012f"+ + "\u0001\u012f\u0005\u012f\u14dc\b\u012f\n\u012f\f\u012f\u14df\t\u012f\u0001"+ + "\u0130\u0001\u0130\u0001\u0130\u0003\u0130\u14e4\b\u0130\u0001\u0131\u0001"+ + "\u0131\u0003\u0131\u14e8\b\u0131\u0001\u0132\u0001\u0132\u0001\u0132\u0003"+ + "\u0132\u14ed\b\u0132\u0001\u0133\u0001\u0133\u0001\u0133\u0001\u0133\u0001"+ + "\u0133\u0003\u0133\u14f4\b\u0133\u0001\u0134\u0001\u0134\u0001\u0134\u0001"+ + "\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001\u0134\u0001"+ + "\u0134\u0001\u0134\u0001\u0134\u0003\u0134\u1502\b\u0134\u0003\u0134\u1504"+ + "\b\u0134\u0001\u0134\u0001\u0134\u0001\u0135\u0001\u0135\u0001\u0135\u0003"+ + "\u0135\u150b\b\u0135\u0001\u0136\u0001\u0136\u0003\u0136\u150f\b\u0136"+ + "\u0001\u0136\u0001\u0136\u0001\u0137\u0001\u0137\u0001\u0137\u0005\u0137"+ + "\u1516\b\u0137\n\u0137\f\u0137\u1519\t\u0137\u0001\u0138\u0001\u0138\u0001"+ + "\u0138\u0005\u0138\u151e\b\u0138\n\u0138\f\u0138\u1521\t\u0138\u0001\u0139"+ + "\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0001\u0139\u0003\u0139"+ + "\u1529\b\u0139\u0003\u0139\u152b\b\u0139\u0001\u013a\u0001\u013a\u0003"+ + "\u013a\u152f\b\u013a\u0001\u013a\u0001\u013a\u0001\u013b\u0001\u013b\u0001"+ + "\u013b\u0005\u013b\u1536\b\u013b\n\u013b\f\u013b\u1539\t\u013b\u0001\u013c"+ + "\u0001\u013c\u0003\u013c\u153d\b\u013c\u0001\u013c\u0001\u013c\u0001\u013c"+ + "\u0001\u013c\u0003\u013c\u1543\b\u013c\u0001\u013c\u0001\u013c\u0001\u013c"+ + "\u0003\u013c\u1548\b\u013c\u0001\u013d\u0001\u013d\u0003\u013d\u154c\b"+ + "\u013d\u0001\u013d\u0001\u013d\u0001\u013d\u0003\u013d\u1551\b\u013d\u0001"+ + "\u013e\u0001\u013e\u0001\u013e\u0001\u013e\u0003\u013e\u1557\b\u013e\u0001"+ + "\u013f\u0001\u013f\u0001\u0140\u0001\u0140\u0003\u0140\u155d\b\u0140\u0001"+ + "\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0003\u0140\u1563\b\u0140\u0001"+ + "\u0140\u0001\u0140\u0001\u0140\u0001\u0140\u0003\u0140\u1569\b\u0140\u0001"+ + "\u0141\u0001\u0141\u0001\u0141\u0003\u0141\u156e\b\u0141\u0001\u0142\u0001"+ + "\u0142\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001"+ + "\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0001\u0143\u0003"+ + "\u0143\u157d\b\u0143\u0001\u0143\u0001\u0143\u0001\u0144\u0001\u0144\u0001"+ + "\u0144\u0005\u0144\u1584\b\u0144\n\u0144\f\u0144\u1587\t\u0144\u0001\u0145"+ + "\u0001\u0145\u0001\u0145\u0001\u0146\u0001\u0146\u0001\u0146\u0005\u0146"+ + "\u158f\b\u0146\n\u0146\f\u0146\u1592\t\u0146\u0001\u0147\u0004\u0147\u1595"+ + "\b\u0147\u000b\u0147\f\u0147\u1596\u0001\u0147\u0001\u0147\u0001\u0148"+ + "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148"+ + "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148"+ + "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148"+ + "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148"+ + "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148"+ + "\u0001\u0148\u0001\u0148\u0001\u0148\u0001\u0148\u0003\u0148\u15be\b\u0148"+ + "\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149\u0001\u0149"+ + "\u0001\u0149\u0001\u0149\u0003\u0149\u15c8\b\u0149\u0001\u014a\u0001\u014a"+ + "\u0001\u014a\u0001\u014a\u0001\u014a\u0003\u014a\u15cf\b\u014a\u0001\u014b"+ + "\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b\u0001\u014b"+ + "\u0005\u014b\u15d8\b\u014b\n\u014b\f\u014b\u15db\t\u014b\u0001\u014c\u0001"+ + "\u014c\u0001\u014c\u0003\u014c\u15e0\b\u014c\u0001\u014d\u0001\u014d\u0001"+ + "\u014d\u0001\u014e\u0001\u014e\u0001\u014e\u0005\u014e\u15e8\b\u014e\n"+ + "\u014e\f\u014e\u15eb\t\u014e\u0001\u014f\u0001\u014f\u0001\u014f\u0001"+ + "\u014f\u0001\u014f\u0001\u014f\u0001\u0150\u0004\u0150\u15f4\b\u0150\u000b"+ + "\u0150\f\u0150\u15f5\u0001\u0151\u0001\u0151\u0003\u0151\u15fa\b\u0151"+ + "\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152"+ + "\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152"+ + "\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152"+ + "\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152"+ + "\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152"+ + "\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152\u0001\u0152"+ + "\u0003\u0152\u1620\b\u0152\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153"+ + "\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153\u0001\u0153"+ + "\u0001\u0153\u0001\u0153\u0003\u0153\u162e\b\u0153\u0001\u0154\u0001\u0154"+ + "\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154"+ + "\u0001\u0154\u0001\u0154\u0001\u0154\u0001\u0154\u0003\u0154\u163c\b\u0154"+ + "\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155"+ + "\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155"+ + "\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155"+ + "\u0001\u0155\u0001\u0155\u0001\u0155\u0001\u0155\u0003\u0155\u1654\b\u0155"+ + "\u0001\u0156\u0001\u0156\u0001\u0156\u0005\u0156\u1659\b\u0156\n\u0156"+ + "\f\u0156\u165c\t\u0156\u0001\u0156\u0001\u0156\u0001\u0157\u0001\u0157"+ + "\u0001\u0157\u0005\u0157\u1663\b\u0157\n\u0157\f\u0157\u1666\t\u0157\u0001"+ + "\u0158\u0001\u0158\u0001\u0158\u0001\u0159\u0001\u0159\u0001\u0159\u0001"+ + "\u015a\u0004\u015a\u166f\b\u015a\u000b\u015a\f\u015a\u1670\u0001\u015b"+ + "\u0001\u015b\u0001\u015b\u0003\u015b\u1676\b\u015b\u0001\u015c\u0001\u015c"+ + "\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c"+ + "\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c"+ + "\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c"+ + "\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c"+ + "\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c\u0001\u015c"+ + "\u0001\u015c\u0001\u015c\u0003\u015c\u169a\b\u015c\u0001\u015d\u0001\u015d"+ + "\u0001\u015d\u0001\u015d\u0001\u015d\u0003\u015d\u16a1\b\u015d\u0001\u015e"+ + "\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015e"+ + "\u0001\u015e\u0001\u015e\u0001\u015e\u0001\u015f\u0001\u015f\u0001\u015f"+ + "\u0003\u015f\u16b0\b\u015f\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160"+ + "\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160\u0001\u0160"+ + "\u0001\u0160\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161"+ + "\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161"+ + "\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161"+ + "\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161"+ + "\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161"+ + "\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0001\u0161\u0003\u0161"+ + "\u16df\b\u0161\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162"+ + "\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0162\u0001\u0163\u0001\u0163"+ + "\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163"+ + "\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163"+ + "\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163"+ + "\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163\u0001\u0163"+ + "\u0003\u0163\u1704\b\u0163\u0001\u0164\u0001\u0164\u0001\u0165\u0001\u0165"+ + "\u0001\u0166\u0001\u0166\u0001\u0166\u0005\u0166\u170d\b\u0166\n\u0166"+ + "\f\u0166\u1710\t\u0166\u0001\u0167\u0001\u0167\u0001\u0168\u0001\u0168"+ + "\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168"+ + "\u0001\u0168\u0001\u0168\u0001\u0168\u0001\u0168\u0003\u0168\u1720\b\u0168"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169\u0001\u0169"+ + "\u0003\u0169\u18f6\b\u0169\u0001\u016a\u0001\u016a\u0003\u016a\u18fa\b"+ + "\u016a\u0001\u016b\u0001\u016b\u0001\u016b\u0003\u016b\u18ff\b\u016b\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001\u016c\u0001"+ + "\u016c\u0001\u016c\u0001\u016c\u0003\u016c\u193a\b\u016c\u0001\u016d\u0001"+ + "\u016d\u0003\u016d\u193e\b\u016d\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0001"+ + "\u016e\u0001\u016e\u0001\u016e\u0001\u016e\u0003\u016e\u1a19\b\u016e\u0001"+ + "\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001\u016f\u0001"+ + "\u016f\u0001\u016f\u0001\u0170\u0001\u0170\u0001\u0170\u0005\u0170\u1a26"+ + "\b\u0170\n\u0170\f\u0170\u1a29\t\u0170\u0001\u0171\u0001\u0171\u0001\u0171"+ + "\u0001\u0171\u0001\u0171\u0001\u0171\u0001\u0171\u0001\u0171\u0003\u0171"+ + "\u1a33\b\u0171\u0001\u0172\u0001\u0172\u0001\u0172\u0001\u0172\u0001\u0172"+ + "\u0003\u0172\u1a3a\b\u0172\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0173"+ + "\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0173\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174\u0001\u0174"+ + "\u0001\u0174\u0003\u0174\u1afb\b\u0174\u0001\u0175\u0001\u0175\u0001\u0175"+ + "\u0001\u0175\u0001\u0175\u0001\u0175\u0001\u0176\u0001\u0176\u0003\u0176"+ + "\u1b05\b\u0176\u0001\u0177\u0001\u0177\u0001\u0177\u0001\u0177\u0001\u0177"+ + "\u0001\u0177\u0003\u0177\u1b0d\b\u0177\u0001\u0178\u0001\u0178\u0001\u0178"+ + "\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178"+ + "\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178"+ + "\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178"+ + "\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178\u0001\u0178"+ + "\u0003\u0178\u1b2a\b\u0178\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179"+ + "\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u0179\u0001\u017a"+ + "\u0001\u017a\u0001\u017a\u0005\u017a\u1b38\b\u017a\n\u017a\f\u017a\u1b3b"+ + "\t\u017a\u0001\u017b\u0001\u017b\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0001"+ + "\u017c\u0001\u017c\u0001\u017c\u0001\u017c\u0003\u017c\u1b64\b\u017c\u0001"+ + "\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001"+ + "\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0001\u017d\u0003"+ + "\u017d\u1b72\b\u017d\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001"+ + "\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001"+ + "\u017e\u0001\u017e\u0001\u017e\u0001\u017e\u0001\u017f\u0001\u017f\u0001"+ + "\u017f\u0001\u017f\u0001\u017f\u0001\u017f\u0003\u017f\u1b88\b\u017f\u0001"+ + "\u0180\u0001\u0180\u0001\u0180\u0005\u0180\u1b8d\b\u0180\n\u0180\f\u0180"+ + "\u1b90\t\u0180\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0181\u0001\u0181"+ + "\u0003\u0181\u1b97\b\u0181\u0001\u0182\u0001\u0182\u0003\u0182\u1b9b\b"+ + "\u0182\u0001\u0183\u0001\u0183\u0001\u0184\u0001\u0184\u0001\u0184\u0003"+ + "\u0184\u1ba2\b\u0184\u0001\u0185\u0001\u0185\u0001\u0185\u0001\u0185\u0001"+ + "\u0186\u0001\u0186\u0001\u0186\u0003\u0186\u1bab\b\u0186\u0001\u0187\u0001"+ + "\u0187\u0001\u0187\u0001\u0188\u0001\u0188\u0001\u0188\u0001\u0188\u0003"+ + "\u0188\u1bb4\b\u0188\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0001"+ + "\u0189\u0001\u0189\u0001\u0189\u0001\u0189\u0003\u0189\u1be8\b\u0189\u0001"+ + "\u018a\u0001\u018a\u0001\u018a\u0003\u018a\u1bed\b\u018a\u0001\u018b\u0001"+ + "\u018b\u0001\u018b\u0001\u018b\u0001\u018b\u0001\u018b\u0001\u018b\u0001"+ + "\u018b\u0001\u018b\u0001\u018b\u0003\u018b\u1bf9\b\u018b\u0001\u018c\u0001"+ + "\u018c\u0003\u018c\u1bfd\b\u018c\u0001\u018c\u0005\u018c\u1c00\b\u018c"+ + "\n\u018c\f\u018c\u1c03\t\u018c\u0001\u018d\u0001\u018d\u0003\u018d\u1c07"+ + "\b\u018d\u0001\u018e\u0001\u018e\u0003\u018e\u1c0b\b\u018e\u0001\u018e"+ + "\u0001\u018e\u0003\u018e\u1c0f\b\u018e\u0001\u018f\u0001\u018f\u0001\u018f"+ + "\u0003\u018f\u1c14\b\u018f\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u018f"+ + "\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u018f"+ + "\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u018f\u0003\u018f\u1c24\b\u018f"+ + "\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u018f\u0001\u0190\u0001\u0190"+ + "\u0003\u0190\u1c2c\b\u0190\u0001\u0190\u0001\u0190\u0001\u0190\u0003\u0190"+ + "\u1c31\b\u0190\u0001\u0191\u0001\u0191\u0001\u0191\u0001\u0192\u0001\u0192"+ + "\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0192\u0001\u0193\u0001\u0193"+ + "\u0003\u0193\u1c3e\b\u0193\u0001\u0194\u0004\u0194\u1c41\b\u0194\u000b"+ + "\u0194\f\u0194\u1c42\u0001\u0195\u0001\u0195\u0001\u0195\u0001\u0195\u0001"+ + "\u0195\u0003\u0195\u1c4a\b\u0195\u0001\u0196\u0001\u0196\u0001\u0196\u0001"+ + "\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0001\u0196\u0003\u0196\u1c54"+ + "\b\u0196\u0001\u0197\u0001\u0197\u0003\u0197\u1c58\b\u0197\u0001\u0198"+ + "\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0198\u0001\u0198"+ + "\u0001\u0198\u0001\u0198\u0003\u0198\u1c63\b\u0198\u0001\u0199\u0001\u0199"+ + "\u0001\u0199\u0001\u0199\u0001\u0199\u0001\u019a\u0001\u019a\u0001\u019a"+ + "\u0001\u019a\u0003\u019a\u1c6e\b\u019a\u0001\u019a\u0001\u019a\u0001\u019a"+ + "\u0001\u019a\u0001\u019a\u0001\u019a\u0003\u019a\u1c76\b\u019a\u0001\u019b"+ + "\u0001\u019b\u0001\u019b\u0005\u019b\u1c7b\b\u019b\n\u019b\f\u019b\u1c7e"+ + "\t\u019b\u0001\u019c\u0001\u019c\u0001\u019d\u0001\u019d\u0001\u019d\u0001"+ + "\u019d\u0001\u019d\u0001\u019d\u0001\u019e\u0001\u019e\u0001\u019e\u0001"+ + "\u019e\u0001\u019e\u0001\u019f\u0001\u019f\u0001\u019f\u0001\u019f\u0001"+ + "\u019f\u0001\u019f\u0001\u019f\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001"+ + "\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001"+ + "\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001"+ + "\u01a0\u0003\u01a0\u1ca4\b\u01a0\u0001\u01a0\u0001\u01a0\u0001\u01a0\u0001"+ + "\u01a0\u0001\u01a0\u0001\u01a0\u0003\u01a0\u1cac\b\u01a0\u0001\u01a1\u0001"+ + "\u01a1\u0003\u01a1\u1cb0\b\u01a1\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001"+ + "\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a2\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0001"+ + "\u01a3\u0001\u01a3\u0001\u01a3\u0001\u01a3\u0003\u01a3\u1d01\b\u01a3\u0001"+ + "\u01a4\u0001\u01a4\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001"+ + "\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001\u01a5\u0001"+ + "\u01a5\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001"+ + "\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001\u01a6\u0001"+ + "\u01a6\u0001\u01a6\u0003\u01a6\u1d1d\b\u01a6\u0001\u01a7\u0001\u01a7\u0001"+ + "\u01a7\u0003\u01a7\u1d22\b\u01a7\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001"+ + "\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0001"+ + "\u01a8\u0001\u01a8\u0001\u01a8\u0001\u01a8\u0003\u01a8\u1d31\b\u01a8\u0001"+ + "\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0001"+ + "\u01a9\u0001\u01a9\u0001\u01a9\u0001\u01a9\u0003\u01a9\u1d3d\b\u01a9\u0001"+ + "\u01aa\u0001\u01aa\u0001\u01aa\u0005\u01aa\u1d42\b\u01aa\n\u01aa\f\u01aa"+ + "\u1d45\t\u01aa\u0001\u01ab\u0001\u01ab\u0001\u01ac\u0001\u01ac\u0001\u01ac"+ + "\u0001\u01ad\u0001\u01ad\u0003\u01ad\u1d4e\b\u01ad\u0001\u01ae\u0001\u01ae"+ + "\u0001\u01ae\u0003\u01ae\u1d53\b\u01ae\u0001\u01af\u0001\u01af\u0003\u01af"+ + "\u1d57\b\u01af\u0001\u01b0\u0001\u01b0\u0003\u01b0\u1d5b\b\u01b0\u0001"+ + "\u01b1\u0001\u01b1\u0003\u01b1\u1d5f\b\u01b1\u0001\u01b2\u0001\u01b2\u0003"+ + "\u01b2\u1d63\b\u01b2\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001\u01b3\u0001"+ + "\u01b3\u0003\u01b3\u1d6a\b\u01b3\u0001\u01b4\u0001\u01b4\u0001\u01b4\u0001"+ + "\u01b5\u0001\u01b5\u0001\u01b5\u0005\u01b5\u1d72\b\u01b5\n\u01b5\f\u01b5"+ + "\u1d75\t\u01b5\u0001\u01b6\u0001\u01b6\u0003\u01b6\u1d79\b\u01b6\u0001"+ + "\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001"+ + "\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0001"+ + "\u01b7\u0001\u01b7\u0001\u01b7\u0001\u01b7\u0003\u01b7\u1d8b\b\u01b7\u0001"+ + "\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001\u01b8\u0001"+ + "\u01b8\u0001\u01b8\u0001\u01b8\u0003\u01b8\u1d96\b\u01b8\u0001\u01b9\u0001"+ + "\u01b9\u0001\u01b9\u0005\u01b9\u1d9b\b\u01b9\n\u01b9\f\u01b9\u1d9e\t\u01b9"+ + "\u0001\u01ba\u0001\u01ba\u0001\u01ba\u0001\u01bb\u0001\u01bb\u0003\u01bb"+ + "\u1da5\b\u01bb\u0001\u01bc\u0001\u01bc\u0001\u01bc\u0003\u01bc\u1daa\b"+ + "\u01bc\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001\u01bd\u0001"+ + "\u01bd\u0001\u01be\u0001\u01be\u0001\u01be\u0001\u01be\u0001\u01be\u0003"+ + "\u01be\u1db7\b\u01be\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0001\u01bf\u0003"+ + "\u01bf\u1dbd\b\u01bf\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001"+ + "\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001"+ + "\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001"+ + "\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001"+ + "\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0001\u01c0\u0003\u01c0\u1dda"+ + "\b\u01c0\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0001\u01c1\u0003"+ + "\u01c1\u1de1\b\u01c1\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001"+ + "\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0001\u01c2\u0003"+ + "\u01c2\u1ded\b\u01c2\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001"+ + "\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c3\u0001\u01c4\u0001\u01c4\u0001"+ + "\u01c4\u0003\u01c4\u1dfa\b\u01c4\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001"+ + "\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0001"+ + "\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0003\u01c5\u1e09\b\u01c5\u0001"+ + "\u01c5\u0001\u01c5\u0001\u01c5\u0001\u01c5\u0003\u01c5\u1e0f\b\u01c5\u0001"+ + "\u01c6\u0001\u01c6\u0001\u01c7\u0001\u01c7\u0001\u01c7\u0005\u01c7\u1e16"+ + "\b\u01c7\n\u01c7\f\u01c7\u1e19\t\u01c7\u0001\u01c8\u0001\u01c8\u0001\u01c8"+ + "\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9"+ + "\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0001\u01c9\u0003\u01c9\u1e28\b\u01c9"+ + "\u0001\u01c9\u0003\u01c9\u1e2b\b\u01c9\u0001\u01ca\u0001\u01ca\u0001\u01ca"+ + "\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca\u0001\u01ca"+ + "\u0003\u01ca\u1e36\b\u01ca\u0001\u01cb\u0001\u01cb\u0001\u01cb\u0003\u01cb"+ + "\u1e3b\b\u01cb\u0001\u01cc\u0001\u01cc\u0003\u01cc\u1e3f\b\u01cc\u0001"+ + "\u01cc\u0001\u01cc\u0003\u01cc\u1e43\b\u01cc\u0001\u01cc\u0001\u01cc\u0001"+ + "\u01cc\u0003\u01cc\u1e48\b\u01cc\u0001\u01cc\u0003\u01cc\u1e4b\b\u01cc"+ + "\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0001\u01cc\u0003\u01cc\u1e51\b\u01cc"+ + "\u0001\u01cc\u0001\u01cc\u0003\u01cc\u1e55\b\u01cc\u0003\u01cc\u1e57\b"+ + "\u01cc\u0001\u01cc\u0003\u01cc\u1e5a\b\u01cc\u0001\u01cd\u0001\u01cd\u0001"+ + "\u01cd\u0001\u01cd\u0001\u01cd\u0003\u01cd\u1e61\b\u01cd\u0001\u01cd\u0003"+ + "\u01cd\u1e64\b\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01cd\u0001"+ + "\u01cd\u0003\u01cd\u1e6b\b\u01cd\u0001\u01cd\u0001\u01cd\u0001\u01ce\u0001"+ + "\u01ce\u0001\u01ce\u0001\u01ce\u0003\u01ce\u1e73\b\u01ce\u0001\u01ce\u0003"+ + "\u01ce\u1e76\b\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001\u01ce\u0001"+ + "\u01cf\u0001\u01cf\u0001\u01cf\u0003\u01cf\u1e7f\b\u01cf\u0001\u01cf\u0001"+ + "\u01cf\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d0\u0001"+ + "\u01d0\u0001\u01d0\u0001\u01d0\u0001\u01d1\u0001\u01d1\u0001\u01d1\u0003"+ + "\u01d1\u1e8e\b\u01d1\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001\u01d2\u0001"+ + "\u01d2\u0001\u01d2\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001\u01d3\u0001"+ + "\u01d3\u0003\u01d3\u1e9b\b\u01d3\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001"+ + "\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0001\u01d4\u0003"+ + "\u01d4\u1ea6\b\u01d4\u0001\u01d4\u0003\u01d4\u1ea9\b\u01d4\u0001\u01d5"+ + "\u0001\u01d5\u0003\u01d5\u1ead\b\u01d5\u0001\u01d6\u0001\u01d6\u0001\u01d6"+ + "\u0001\u01d6\u0003\u01d6\u1eb3\b\u01d6\u0001\u01d7\u0001\u01d7\u0001\u01d7"+ + "\u0001\u01d7\u0001\u01d7\u0001\u01d7\u0001\u01d7\u0001\u01d7\u0001\u01d7"+ + "\u0001\u01d8\u0001\u01d8\u0001\u01d8\u0005\u01d8\u1ec1\b\u01d8\n\u01d8"+ + "\f\u01d8\u1ec4\t\u01d8\u0001\u01d9\u0001\u01d9\u0001\u01d9\u0001\u01d9"+ + "\u0001\u01d9\u0001\u01d9\u0001\u01d9\u0001\u01d9\u0001\u01d9\u0001\u01d9"+ + "\u0003\u01d9\u1ed0\b\u01d9\u0001\u01da\u0001\u01da\u0001\u01da\u0001\u01db"+ + "\u0001\u01db\u0001\u01db\u0005\u01db\u1ed8\b\u01db\n\u01db\f\u01db\u1edb"+ + "\t\u01db\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dc\u0001"+ + "\u01dc\u0001\u01dc\u0001\u01dc\u0001\u01dd\u0001\u01dd\u0001\u01de\u0001"+ + "\u01de\u0001\u01de\u0001\u01de\u0001\u01de\u0005\u01de\u1eec\b\u01de\n"+ + "\u01de\f\u01de\u1eef\t\u01de\u0001\u01df\u0001\u01df\u0001\u01df\u0001"+ + "\u01df\u0001\u01df\u0003\u01df\u1ef6\b\u01df\u0001\u01e0\u0001\u01e0\u0003"+ + "\u01e0\u1efa\b\u01e0\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0001"+ + "\u01e1\u0001\u01e1\u0001\u01e1\u0001\u01e1\u0003\u01e1\u1f04\b\u01e1\u0001"+ + "\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001"+ + "\u01e2\u0001\u01e2\u0003\u01e2\u1f0e\b\u01e2\u0001\u01e2\u0001\u01e2\u0001"+ + "\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001\u01e2\u0001"+ + "\u01e2\u0003\u01e2\u1f19\b\u01e2\u0003\u01e2\u1f1b\b\u01e2\u0001\u01e3"+ + "\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0001\u01e3\u0005\u01e3\u1f22\b\u01e3"+ + "\n\u01e3\f\u01e3\u1f25\t\u01e3\u0001\u01e4\u0001\u01e4\u0001\u01e4\u0001"+ + "\u01e4\u0001\u01e4\u0005\u01e4\u1f2c\b\u01e4\n\u01e4\f\u01e4\u1f2f\t\u01e4"+ + "\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5"+ + "\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0003\u01e5"+ + "\u1f3c\b\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5"+ + "\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5\u0001\u01e5"+ + "\u0003\u01e5\u1f49\b\u01e5\u0001\u01e6\u0001\u01e6\u0001\u01e6\u0001\u01e7"+ + "\u0001\u01e7\u0003\u01e7\u1f50\b\u01e7\u0001\u01e7\u0001\u01e7\u0001\u01e8"+ + "\u0001\u01e8\u0001\u01e8\u0005\u01e8\u1f57\b\u01e8\n\u01e8\f\u01e8\u1f5a"+ + "\t\u01e8\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01e9\u0001"+ + "\u01e9\u0001\u01e9\u0001\u01e9\u0001\u01ea\u0001\u01ea\u0001\u01ea\u0001"+ + "\u01ea\u0003\u01ea\u1f68\b\u01ea\u0001\u01eb\u0001\u01eb\u0003\u01eb\u1f6c"+ + "\b\u01eb\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0001\u01ec\u0003"+ + "\u01ec\u1f73\b\u01ec\u0001\u01ec\u0003\u01ec\u1f76\b\u01ec\u0001\u01ed"+ + "\u0001\u01ed\u0003\u01ed\u1f7a\b\u01ed\u0001\u01ee\u0003\u01ee\u1f7d\b"+ + "\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001"+ + "\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0001\u01ee\u0003"+ + "\u01ee\u1f8a\b\u01ee\u0001\u01ef\u0001\u01ef\u0003\u01ef\u1f8e\b\u01ef"+ + "\u0001\u01f0\u0001\u01f0\u0001\u01f0\u0003\u01f0\u1f93\b\u01f0\u0001\u01f1"+ + "\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0001\u01f1\u0003\u01f1"+ + "\u1f9b\b\u01f1\u0001\u01f2\u0001\u01f2\u0003\u01f2\u1f9f\b\u01f2\u0001"+ + "\u01f3\u0001\u01f3\u0003\u01f3\u1fa3\b\u01f3\u0001\u01f4\u0001\u01f4\u0001"+ + "\u01f4\u0001\u01f4\u0001\u01f5\u0001\u01f5\u0001\u01f5\u0005\u01f5\u1fac"+ + "\b\u01f5\n\u01f5\f\u01f5\u1faf\t\u01f5\u0001\u01f6\u0001\u01f6\u0001\u01f6"+ + "\u0001\u01f6\u0003\u01f6\u1fb5\b\u01f6\u0001\u01f6\u0001\u01f6\u0001\u01f7"+ + "\u0001\u01f7\u0003\u01f7\u1fbb\b\u01f7\u0001\u01f7\u0001\u01f7\u0003\u01f7"+ + "\u1fbf\b\u01f7\u0003\u01f7\u1fc1\b\u01f7\u0001\u01f8\u0001\u01f8\u0003"+ + "\u01f8\u1fc5\b\u01f8\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0003"+ + "\u01f9\u1fcb\b\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001\u01f9\u0001"+ + "\u01f9\u0001\u01f9\u0001\u01f9\u0003\u01f9\u1fd4\b\u01f9\u0001\u01f9\u0001"+ + "\u01f9\u0001\u01f9\u0001\u01f9\u0003\u01f9\u1fda\b\u01f9\u0003\u01f9\u1fdc"+ + "\b\u01f9\u0003\u01f9\u1fde\b\u01f9\u0001\u01fa\u0001\u01fa\u0001\u01fa"+ + "\u0001\u01fa\u0001\u01fa\u0003\u01fa\u1fe5\b\u01fa\u0001\u01fb\u0001\u01fb"+ + "\u0003\u01fb\u1fe9\b\u01fb\u0001\u01fc\u0001\u01fc\u0001\u01fd\u0001\u01fd"+ + "\u0001\u01fd\u0001\u01fd\u0001\u01fd\u0003\u01fd\u1ff2\b\u01fd\u0001\u01fe"+ + "\u0001\u01fe\u0003\u01fe\u1ff6\b\u01fe\u0001\u01ff\u0001\u01ff\u0001\u0200"+ + "\u0001\u0200\u0001\u0201\u0001\u0201\u0001\u0201\u0001\u0201\u0003\u0201"+ + "\u2000\b\u0201\u0001\u0202\u0001\u0202\u0001\u0202\u0005\u0202\u2005\b"+ + "\u0202\n\u0202\f\u0202\u2008\t\u0202\u0001\u0203\u0001\u0203\u0001\u0203"+ + "\u0001\u0203\u0001\u0203\u0003\u0203\u200f\b\u0203\u0001\u0204\u0001\u0204"+ + "\u0001\u0204\u0001\u0205\u0001\u0205\u0001\u0205\u0001\u0205\u0001\u0205"+ + "\u0001\u0206\u0001\u0206\u0001\u0206\u0001\u0206\u0001\u0206\u0001\u0207"+ + "\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0207\u0001\u0208"+ + "\u0001\u0208\u0001\u0208\u0003\u0208\u2027\b\u0208\u0001\u0209\u0001\u0209"+ + "\u0001\u0209\u0001\u0209\u0003\u0209\u202d\b\u0209\u0001\u020a\u0001\u020a"+ + "\u0003\u020a\u2031\b\u020a\u0001\u020b\u0004\u020b\u2034\b\u020b\u000b"+ + "\u020b\f\u020b\u2035\u0001\u020c\u0001\u020c\u0001\u020c\u0001\u020c\u0001"+ + "\u020d\u0001\u020d\u0001\u020d\u0003\u020d\u203f\b\u020d\u0001\u020d\u0001"+ + "\u020d\u0003\u020d\u2043\b\u020d\u0001\u020d\u0003\u020d\u2046\b\u020d"+ + "\u0001\u020e\u0001\u020e\u0001\u020e\u0003\u020e\u204b\b\u020e\u0001\u020f"+ + "\u0001\u020f\u0001\u020f\u0001\u020f\u0001\u020f\u0001\u020f\u0001\u020f"+ + "\u0001\u020f\u0001\u020f\u0005\u020f\u2056\b\u020f\n\u020f\f\u020f\u2059"+ + "\t\u020f\u0001\u0210\u0001\u0210\u0001\u0210\u0003\u0210\u205e\b\u0210"+ + "\u0001\u0211\u0001\u0211\u0001\u0211\u0001\u0211\u0005\u0211\u2064\b\u0211"+ + "\n\u0211\f\u0211\u2067\t\u0211\u0003\u0211\u2069\b\u0211\u0001\u0212\u0001"+ + "\u0212\u0001\u0212\u0004\u0212\u206e\b\u0212\u000b\u0212\f\u0212\u206f"+ + "\u0001\u0213\u0001\u0213\u0001\u0213\u0003\u0213\u2075\b\u0213\u0001\u0213"+ + "\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213"+ + "\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213"+ + "\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213"+ + "\u0003\u0213\u208a\b\u0213\u0001\u0213\u0001\u0213\u0001\u0213\u0001\u0213"+ + "\u0001\u0213\u0001\u0213\u0001\u0213\u0003\u0213\u2093\b\u0213\u0001\u0213"+ + "\u0001\u0213\u0001\u0213\u0003\u0213\u2098\b\u0213\u0001\u0213\u0001\u0213"+ + "\u0001\u0213\u0001\u0213\u0003\u0213\u209e\b\u0213\u0001\u0213\u0001\u0213"+ + "\u0001\u0213\u0003\u0213\u20a3\b\u0213\u0001\u0213\u0001\u0213\u0001\u0213"+ + "\u0001\u0213\u0001\u0213\u0003\u0213\u20aa\b\u0213\u0001\u0213\u0001\u0213"+ + "\u0001\u0213\u0003\u0213\u20af\b\u0213\u0001\u0213\u0001\u0213\u0001\u0213"+ + "\u0001\u0213\u0005\u0213\u20b5\b\u0213\n\u0213\f\u0213\u20b8\t\u0213\u0001"+ + "\u0214\u0003\u0214\u20bb\b\u0214\u0001\u0214\u0001\u0214\u0001\u0214\u0001"+ + "\u0214\u0001\u0214\u0003\u0214\u20c2\b\u0214\u0001\u0215\u0001\u0215\u0003"+ + "\u0215\u20c6\b\u0215\u0001\u0216\u0003\u0216\u20c9\b\u0216\u0001\u0216"+ + "\u0001\u0216\u0001\u0216\u0001\u0216\u0001\u0216\u0003\u0216\u20d0\b\u0216"+ + "\u0001\u0217\u0001\u0217\u0001\u0217\u0003\u0217\u20d5\b\u0217\u0001\u0217"+ + "\u0003\u0217\u20d8\b\u0217\u0001\u0217\u0001\u0217\u0001\u0217\u0001\u0217"+ + "\u0001\u0217\u0003\u0217\u20df\b\u0217\u0001\u0218\u0001\u0218\u0003\u0218"+ + "\u20e3\b\u0218\u0001\u0219\u0001\u0219\u0001\u0219\u0001\u0219\u0001\u0219"+ + "\u0001\u0219\u0001\u0219\u0003\u0219\u20ec\b\u0219\u0001\u021a\u0001\u021a"+ + "\u0003\u021a\u20f0\b\u021a\u0001\u021a\u0001\u021a\u0001\u021a\u0001\u021a"+ + "\u0001\u021a\u0001\u021a\u0003\u021a\u20f8\b\u021a\u0003\u021a\u20fa\b"+ + "\u021a\u0001\u021b\u0001\u021b\u0001\u021b\u0005\u021b\u20ff\b\u021b\n"+ + "\u021b\f\u021b\u2102\t\u021b\u0001\u021c\u0001\u021c\u0003\u021c\u2106"+ + "\b\u021c\u0001\u021c\u0003\u021c\u2109\b\u021c\u0001\u021d\u0001\u021d"+ + "\u0001\u021d\u0001\u021d\u0001\u021d\u0001\u021d\u0001\u021d\u0001\u021e"+ + "\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e\u0001\u021e\u0003\u021e"+ + "\u2118\b\u021e\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f"+ + "\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0001\u021f\u0003\u021f"+ + "\u2124\b\u021f\u0001\u0220\u0001\u0220\u0001\u0220\u0001\u0221\u0001\u0221"+ + "\u0001\u0221\u0005\u0221\u212c\b\u0221\n\u0221\f\u0221\u212f\t\u0221\u0001"+ + "\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0001\u0222\u0003"+ + "\u0222\u2137\b\u0222\u0001\u0223\u0001\u0223\u0001\u0223\u0003\u0223\u213c"+ + "\b\u0223\u0001\u0224\u0001\u0224\u0001\u0224\u0003\u0224\u2141\b\u0224"+ + "\u0001\u0225\u0001\u0225\u0001\u0225\u0001\u0225\u0001\u0225\u0003\u0225"+ + "\u2148\b\u0225\u0001\u0225\u0003\u0225\u214b\b\u0225\u0001\u0226\u0001"+ + "\u0226\u0003\u0226\u214f\b\u0226\u0001\u0227\u0001\u0227\u0001\u0227\u0005"+ + "\u0227\u2154\b\u0227\n\u0227\f\u0227\u2157\t\u0227\u0001\u0228\u0001\u0228"+ + "\u0001\u0228\u0001\u0228\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229"+ + "\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229"+ + "\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229\u0001\u0229"+ + "\u0001\u0229\u0003\u0229\u216e\b\u0229\u0001\u0229\u0001\u0229\u0001\u022a"+ + "\u0001\u022a\u0001\u022a\u0005\u022a\u2175\b\u022a\n\u022a\f\u022a\u2178"+ + "\t\u022a\u0001\u022b\u0001\u022b\u0001\u022b\u0003\u022b\u217d\b\u022b"+ + "\u0001\u022b\u0001\u022b\u0003\u022b\u2181\b\u022b\u0001\u022c\u0004\u022c"+ + "\u2184\b\u022c\u000b\u022c\f\u022c\u2185\u0001\u022d\u0001\u022d\u0001"+ + "\u022d\u0001\u022d\u0001\u022d\u0001\u022d\u0001\u022d\u0001\u022d\u0003"+ + "\u022d\u2190\b\u022d\u0001\u022e\u0001\u022e\u0001\u022e\u0005\u022e\u2195"+ + "\b\u022e\n\u022e\f\u022e\u2198\t\u022e\u0001\u022f\u0001\u022f\u0001\u022f"+ + "\u0001\u022f\u0001\u022f\u0001\u022f\u0003\u022f\u21a0\b\u022f\u0001\u0230"+ + "\u0003\u0230\u21a3\b\u0230\u0001\u0230\u0001\u0230\u0001\u0230\u0001\u0230"+ + "\u0001\u0230\u0001\u0230\u0001\u0230\u0003\u0230\u21ac\b\u0230\u0003\u0230"+ + "\u21ae\b\u0230\u0001\u0230\u0001\u0230\u0001\u0230\u0001\u0230\u0003\u0230"+ + "\u21b4\b\u0230\u0001\u0231\u0001\u0231\u0003\u0231\u21b8\b\u0231\u0001"+ + "\u0231\u0005\u0231\u21bb\b\u0231\n\u0231\f\u0231\u21be\t\u0231\u0001\u0232"+ + "\u0001\u0232\u0001\u0232\u0001\u0232\u0001\u0232\u0001\u0232\u0001\u0232"+ + "\u0001\u0232\u0001\u0232\u0001\u0232\u0001\u0232\u0003\u0232\u21cb\b\u0232"+ + "\u0003\u0232\u21cd\b\u0232\u0001\u0233\u0001\u0233\u0001\u0233\u0001\u0233"+ + "\u0003\u0233\u21d3\b\u0233\u0001\u0234\u0001\u0234\u0001\u0234\u0001\u0234"+ + "\u0003\u0234\u21d9\b\u0234\u0001\u0234\u0003\u0234\u21dc\b\u0234\u0001"+ + "\u0234\u0001\u0234\u0001\u0235\u0001\u0235\u0001\u0235\u0001\u0235\u0001"+ + "\u0235\u0003\u0235\u21e5\b\u0235\u0001\u0236\u0001\u0236\u0001\u0236\u0001"+ + "\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001"+ + "\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001\u0236\u0001"+ + "\u0236\u0003\u0236\u21f7\b\u0236\u0001\u0237\u0001\u0237\u0001\u0237\u0001"+ + "\u0237\u0001\u0237\u0003\u0237\u21fe\b\u0237\u0001\u0238\u0001\u0238\u0003"+ + "\u0238\u2202\b\u0238\u0001\u0239\u0001\u0239\u0003\u0239\u2206\b\u0239"+ + "\u0001\u023a\u0001\u023a\u0001\u023a\u0001\u023a\u0001\u023a\u0001\u023a"+ + "\u0001\u023b\u0001\u023b\u0001\u023b\u0001\u023c\u0001\u023c\u0001\u023c"+ + "\u0001\u023c\u0001\u023c\u0003\u023c\u2216\b\u023c\u0001\u023d\u0001\u023d"+ + "\u0001\u023d\u0001\u023d\u0001\u023d\u0003\u023d\u221d\b\u023d\u0001\u023e"+ + "\u0001\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0001\u023e\u0003\u023e"+ + "\u2225\b\u023e\u0001\u023f\u0001\u023f\u0003\u023f\u2229\b\u023f\u0001"+ + "\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0001\u0240\u0003\u0240\u2230"+ + "\b\u0240\u0001\u0240\u0001\u0240\u0001\u0241\u0001\u0241\u0001\u0242\u0001"+ + "\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0001\u0242\u0003"+ + "\u0242\u223d\b\u0242\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0003\u0243\u224d\b\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0003\u0243\u2253\b\u0243\u0001"+ + "\u0243\u0001\u0243\u0001\u0243\u0001\u0243\u0003\u0243\u2259\b\u0243\u0001"+ + "\u0244\u0001\u0244\u0001\u0244\u0001\u0244\u0001\u0244\u0003\u0244\u2260"+ + "\b\u0244\u0001\u0245\u0001\u0245\u0001\u0245\u0003\u0245\u2265\b\u0245"+ + "\u0001\u0246\u0001\u0246\u0001\u0247\u0001\u0247\u0003\u0247\u226b\b\u0247"+ + "\u0001\u0248\u0001\u0248\u0001\u0248\u0005\u0248\u2270\b\u0248\n\u0248"+ + "\f\u0248\u2273\t\u0248\u0001\u0249\u0001\u0249\u0001\u0249\u0005\u0249"+ + "\u2278\b\u0249\n\u0249\f\u0249\u227b\t\u0249\u0001\u024a\u0001\u024a\u0001"+ + "\u024a\u0005\u024a\u2280\b\u024a\n\u024a\f\u024a\u2283\t\u024a\u0001\u024b"+ + "\u0001\u024b\u0003\u024b\u2287\b\u024b\u0001\u024b\u0001\u024b\u0003\u024b"+ + "\u228b\b\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0001\u024b\u0003\u024b"+ + "\u2291\b\u024b\u0001\u024c\u0001\u024c\u0003\u024c\u2295\b\u024c\u0001"+ + "\u024c\u0001\u024c\u0003\u024c\u2299\b\u024c\u0001\u024d\u0003\u024d\u229c"+ + "\b\u024d\u0001\u024d\u0001\u024d\u0001\u024e\u0001\u024e\u0003\u024e\u22a2"+ + "\b\u024e\u0001\u024f\u0001\u024f\u0001\u024f\u0003\u024f\u22a7\b\u024f"+ + "\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f"+ + "\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f\u0001\u024f"+ + "\u0001\u024f\u0001\u024f\u0003\u024f\u22b7\b\u024f\u0001\u024f\u0003\u024f"+ + "\u22ba\b\u024f\u0003\u024f\u22bc\b\u024f\u0001\u0250\u0001\u0250\u0001"+ + "\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001\u0250\u0001"+ + "\u0250\u0001\u0250\u0003\u0250\u22c8\b\u0250\u0003\u0250\u22ca\b\u0250"+ + "\u0001\u0251\u0001\u0251\u0003\u0251\u22ce\b\u0251\u0001\u0251\u0001\u0251"+ + "\u0001\u0251\u0001\u0251\u0003\u0251\u22d4\b\u0251\u0001\u0251\u0001\u0251"+ + "\u0001\u0251\u0003\u0251\u22d9\b\u0251\u0001\u0252\u0001\u0252\u0001\u0252"+ + "\u0001\u0252\u0005\u0252\u22df\b\u0252\n\u0252\f\u0252\u22e2\t\u0252\u0001"+ + "\u0253\u0001\u0253\u0003\u0253\u22e6\b\u0253\u0001\u0253\u0003\u0253\u22e9"+ + "\b\u0253\u0001\u0254\u0001\u0254\u0001\u0254\u0005\u0254\u22ee\b\u0254"+ + "\n\u0254\f\u0254\u22f1\t\u0254\u0001\u0255\u0001\u0255\u0001\u0255\u0005"+ + "\u0255\u22f6\b\u0255\n\u0255\f\u0255\u22f9\t\u0255\u0001\u0256\u0001\u0256"+ + "\u0001\u0256\u0003\u0256\u22fe\b\u0256\u0001\u0257\u0003\u0257\u2301\b"+ + "\u0257\u0001\u0257\u0001\u0257\u0001\u0258\u0001\u0258\u0001\u0258\u0001"+ + "\u0258\u0001\u0258\u0003\u0258\u230a\b\u0258\u0001\u0259\u0001\u0259\u0001"+ + "\u0259\u0003\u0259\u230f\b\u0259\u0001\u025a\u0001\u025a\u0001\u025a\u0005"+ + "\u025a\u2314\b\u025a\n\u025a\f\u025a\u2317\t\u025a\u0001\u025b\u0001\u025b"+ + "\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0003\u025b"+ + "\u2320\b\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b"+ + "\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b"+ + "\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b"+ + "\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b"+ + "\u0001\u025b\u0003\u025b\u233a\b\u025b\u0001\u025b\u0001\u025b\u0001\u025b"+ + "\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b\u0001\u025b"+ + "\u0003\u025b\u2345\b\u025b\u0005\u025b\u2347\b\u025b\n\u025b\f\u025b\u234a"+ + "\t\u025b\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0003"+ + "\u025c\u2351\b\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001"+ + "\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001"+ + "\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001"+ + "\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0003\u025c\u2368"+ + "\b\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001\u025c\u0001"+ + "\u025c\u0003\u025c\u2370\b\u025c\u0001\u025d\u0001\u025d\u0001\u025d\u0001"+ + "\u025d\u0001\u025d\u0001\u025d\u0003\u025d\u2378\b\u025d\u0001\u025d\u0001"+ + "\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001"+ + "\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0001\u025d\u0003\u025d\u2386"+ + "\b\u025d\u0001\u025d\u0001\u025d\u0001\u025e\u0001\u025e\u0001\u025e\u0001"+ + "\u025e\u0001\u025e\u0001\u025e\u0003\u025e\u2390\b\u025e\u0001\u025f\u0001"+ + "\u025f\u0003\u025f\u2394\b\u025f\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0003\u0260\u23a2\b\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0003\u0260\u23a9\b\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0003\u0260\u23b0"+ + "\b\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0003"+ + "\u0260\u23b7\b\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0003\u0260\u23d0\b\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0003"+ + "\u0260\u23ed\b\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0003\u0260\u2414\b\u0260\u0003\u0260\u2416"+ + "\b\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0003\u0260\u2432\b\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001"+ + "\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0001\u0260\u0003"+ + "\u0260\u2447\b\u0260\u0001\u0261\u0001\u0261\u0001\u0261\u0001\u0261\u0001"+ + "\u0261\u0003\u0261\u244e\b\u0261\u0001\u0262\u0001\u0262\u0001\u0262\u0001"+ + "\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001\u0262\u0001"+ + "\u0262\u0001\u0262\u0003\u0262\u245b\b\u0262\u0001\u0263\u0001\u0263\u0001"+ + "\u0263\u0001\u0263\u0001\u0263\u0001\u0264\u0001\u0264\u0001\u0264\u0005"+ + "\u0264\u2465\b\u0264\n\u0264\f\u0264\u2468\t\u0264\u0001\u0265\u0001\u0265"+ + "\u0001\u0265\u0003\u0265\u246d\b\u0265\u0001\u0266\u0001\u0266\u0001\u0267"+ + "\u0001\u0267\u0001\u0267\u0001\u0267\u0001\u0267\u0003\u0267\u2476\b\u0267"+ + "\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268"+ + "\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268\u0001\u0268"+ + "\u0001\u0268\u0001\u0268\u0001\u0268\u0003\u0268\u2487\b\u0268\u0001\u0269"+ + "\u0001\u0269\u0001\u0269\u0001\u026a\u0001\u026a\u0001\u026a\u0001\u026a"+ + "\u0001\u026a\u0001\u026a\u0001\u026a\u0003\u026a\u2493\b\u026a\u0001\u026b"+ + "\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b\u0001\u026b"+ + "\u0003\u026b\u249c\b\u026b\u0001\u026c\u0001\u026c\u0001\u026c\u0003\u026c"+ + "\u24a1\b\u026c\u0001\u026d\u0001\u026d\u0001\u026d\u0005\u026d\u24a6\b"+ + "\u026d\n\u026d\f\u026d\u24a9\t\u026d\u0001\u026e\u0001\u026e\u0001\u026e"+ + "\u0001\u026e\u0001\u026f\u0001\u026f\u0001\u026f\u0003\u026f\u24b2\b\u026f"+ + "\u0001\u026f\u0003\u026f\u24b5\b\u026f\u0001\u0270\u0001\u0270\u0001\u0270"+ + "\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0270\u0001\u0271\u0001\u0271"+ + "\u0003\u0271\u24c0\b\u0271\u0001\u0272\u0001\u0272\u0001\u0272\u0001\u0272"+ + "\u0003\u0272\u24c6\b\u0272\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273"+ + "\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273\u0001\u0273"+ + "\u0001\u0273\u0001\u0273\u0001\u0273\u0003\u0273\u24d5\b\u0273\u0001\u0274"+ + "\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0001\u0274\u0003\u0274"+ + "\u24dd\b\u0274\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275\u0001\u0275"+ + "\u0001\u0275\u0001\u0275\u0003\u0275\u24e6\b\u0275\u0001\u0276\u0001\u0276"+ + "\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0001\u0276\u0003\u0276"+ + "\u24ef\b\u0276\u0001\u0276\u0003\u0276\u24f2\b\u0276\u0001\u0277\u0001"+ + "\u0277\u0001\u0277\u0003\u0277\u24f7\b\u0277\u0001\u0277\u0001\u0277\u0001"+ + "\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0001\u0277\u0003\u0277\u2500"+ + "\b\u0277\u0001\u0278\u0001\u0278\u0001\u0278\u0003\u0278\u2505\b\u0278"+ + "\u0001\u0278\u0001\u0278\u0001\u0279\u0001\u0279\u0001\u0279\u0001\u0279"+ + "\u0001\u0279\u0001\u0279\u0001\u027a\u0001\u027a\u0001\u027b\u0001\u027b"+ + "\u0003\u027b\u2513\b\u027b\u0001\u027c\u0001\u027c\u0001\u027d\u0001\u027d"+ + "\u0001\u027d\u0001\u027d\u0001\u027d\u0001\u027d\u0003\u027d\u251d\b\u027d"+ + "\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e\u0001\u027e"+ + "\u0003\u027e\u2525\b\u027e\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f"+ + "\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f\u0001\u027f"+ + "\u0001\u027f\u0001\u027f\u0003\u027f\u2533\b\u027f\u0001\u0280\u0001\u0280"+ + "\u0001\u0280\u0005\u0280\u2538\b\u0280\n\u0280\f\u0280\u253b\t\u0280\u0001"+ + "\u0281\u0001\u0281\u0001\u0281\u0005\u0281\u2540\b\u0281\n\u0281\f\u0281"+ + "\u2543\t\u0281\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0282\u0001\u0282"+ + "\u0003\u0282\u254a\b\u0282\u0001\u0283\u0001\u0283\u0001\u0283\u0005\u0283"+ + "\u254f\b\u0283\n\u0283\f\u0283\u2552\t\u0283\u0001\u0284\u0001\u0284\u0001"+ + "\u0284\u0003\u0284\u2557\b\u0284\u0001\u0284\u0001\u0284\u0001\u0285\u0001"+ + "\u0285\u0001\u0285\u0005\u0285\u255e\b\u0285\n\u0285\f\u0285\u2561\t\u0285"+ + "\u0001\u0286\u0001\u0286\u0001\u0286\u0001\u0286\u0001\u0286\u0003\u0286"+ + "\u2568\b\u0286\u0001\u0287\u0001\u0287\u0001\u0287\u0001\u0287\u0001\u0287"+ + "\u0001\u0287\u0001\u0287\u0001\u0287\u0003\u0287\u2572\b\u0287\u0001\u0288"+ + "\u0001\u0288\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u0289\u0001\u0289"+ + "\u0001\u0289\u0001\u0289\u0003\u0289\u257d\b\u0289\u0001\u028a\u0001\u028a"+ + "\u0001\u028a\u0001\u028a\u0001\u028a\u0003\u028a\u2584\b\u028a\u0001\u028b"+ + "\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b"+ + "\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b"+ + "\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b"+ + "\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b"+ + "\u0001\u028b\u0001\u028b\u0003\u028b\u25a1\b\u028b\u0001\u028c\u0001\u028c"+ + "\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0003\u028c"+ + "\u25aa\b\u028c\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d\u0001\u028d"+ + "\u0003\u028d\u25b1\b\u028d\u0001\u028e\u0001\u028e\u0001\u028e\u0001\u028e"+ + "\u0001\u028e\u0001\u028e\u0001\u028f\u0004\u028f\u25ba\b\u028f\u000b\u028f"+ + "\f\u028f\u25bb\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290\u0001\u0290"+ + "\u0001\u0291\u0001\u0291\u0001\u0291\u0003\u0291\u25c6\b\u0291\u0001\u0292"+ + "\u0001\u0292\u0003\u0292\u25ca\b\u0292\u0001\u0293\u0001\u0293\u0003\u0293"+ + "\u25ce\b\u0293\u0001\u0294\u0001\u0294\u0001\u0294\u0003\u0294\u25d3\b"+ + "\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001\u0294\u0001"+ + "\u0294\u0003\u0294\u25db\b\u0294\u0001\u0294\u0001\u0294\u0003\u0294\u25df"+ + "\b\u0294\u0001\u0295\u0001\u0295\u0003\u0295\u25e3\b\u0295\u0001\u0296"+ + "\u0004\u0296\u25e6\b\u0296\u000b\u0296\f\u0296\u25e7\u0001\u0297\u0005"+ + "\u0297\u25eb\b\u0297\n\u0297\f\u0297\u25ee\t\u0297\u0001\u0298\u0001\u0298"+ + "\u0003\u0298\u25f2\b\u0298\u0001\u0299\u0001\u0299\u0001\u0299\u0005\u0299"+ + "\u25f7\b\u0299\n\u0299\f\u0299\u25fa\t\u0299\u0001\u029a\u0001\u029a\u0001"+ + "\u029a\u0001\u029a\u0001\u029a\u0003\u029a\u2601\b\u029a\u0001\u029a\u0003"+ + "\u029a\u2604\b\u029a\u0001\u029b\u0001\u029b\u0001\u029b\u0005\u029b\u2609"+ + "\b\u029b\n\u029b\f\u029b\u260c\t\u029b\u0001\u029c\u0001\u029c\u0003\u029c"+ + "\u2610\b\u029c\u0001\u029d\u0001\u029d\u0001\u029d\u0005\u029d\u2615\b"+ + "\u029d\n\u029d\f\u029d\u2618\t\u029d\u0001\u029e\u0001\u029e\u0001\u029f"+ + "\u0001\u029f\u0001\u02a0\u0001\u02a0\u0001\u02a1\u0001\u02a1\u0001\u02a1"+ + "\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0003\u02a1\u2627\b\u02a1"+ + "\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2"+ + "\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2"+ + "\u0001\u02a2\u0003\u02a2\u2636\b\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2"+ + "\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0001\u02a2"+ + "\u0001\u02a2\u0001\u02a2\u0001\u02a2\u0003\u02a2\u2644\b\u02a2\u0001\u02a2"+ + "\u0001\u02a2\u0001\u02a2\u0003\u02a2\u2649\b\u02a2\u0001\u02a3\u0001\u02a3"+ + "\u0001\u02a4\u0001\u02a4\u0001\u02a5\u0001\u02a5\u0001\u02a6\u0001\u02a6"+ + "\u0001\u02a7\u0001\u02a7\u0001\u02a7\u0001\u02a8\u0001\u02a8\u0001\u02a8"+ + "\u0001\u02a8\u0005\u02a8\u265a\b\u02a8\n\u02a8\f\u02a8\u265d\t\u02a8\u0001"+ + "\u02a8\u0001\u02a8\u0003\u02a8\u2661\b\u02a8\u0001\u02a9\u0001\u02a9\u0001"+ + "\u02a9\u0003\u02a9\u2666\b\u02a9\u0001\u02aa\u0001\u02aa\u0001\u02aa\u0001"+ + "\u02aa\u0001\u02aa\u0003\u02aa\u266d\b\u02aa\u0001\u02ab\u0001\u02ab\u0001"+ + "\u02ac\u0001\u02ac\u0001\u02ac\u0003\u02ac\u2674\b\u02ac\u0001\u02ad\u0001"+ + "\u02ad\u0001\u02ad\u0005\u02ad\u2679\b\u02ad\n\u02ad\f\u02ad\u267c\t\u02ad"+ + "\u0001\u02ae\u0001\u02ae\u0001\u02ae\u0001\u02ae\u0001\u02ae\u0001\u02ae"+ + "\u0003\u02ae\u2684\b\u02ae\u0001\u02af\u0001\u02af\u0001\u02af\u0001\u02af"+ + "\u0003\u02af\u268a\b\u02af\u0001\u02b0\u0001\u02b0\u0001\u02b0\u0001\u02b0"+ + "\u0003\u02b0\u2690\b\u02b0\u0001\u02b1\u0001\u02b1\u0001\u02b1\u0001\u02b1"+ + "\u0003\u02b1\u2696\b\u02b1\u0001\u02b2\u0001\u02b2\u0001\u02b2\u0001\u02b2"+ + "\u0001\u02b2\u0001\u02b2\u0003\u02b2\u269e\b\u02b2\u0001\u02b3\u0001\u02b3"+ + "\u0001\u02b3\u0001\u02b3\u0001\u02b3\u0001\u02b3\u0003\u02b3\u26a6\b\u02b3"+ + "\u0001\u02b4\u0001\u02b4\u0001\u02b5\u0001\u02b5\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6\u0001\u02b6"+ + "\u0001\u02b6\u0001\u02b6\u0003\u02b6\u26e0\b\u02b6\u0001\u02b7\u0001\u02b7"+ + "\u0001\u02b8\u0001\u02b8\u0001\u02b9\u0001\u02b9\u0001\u02ba\u0001\u02ba"+ + "\u0001\u02ba\u0001\u02ba\u0001\u02bb\u0005\u02bb\u26ed\b\u02bb\n\u02bb"+ + "\f\u02bb\u26f0\t\u02bb\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc"+ + "\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc"+ + "\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc"+ + "\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0001\u02bc\u0003\u02bc\u2706\b\u02bc"+ + "\u0001\u02bd\u0001\u02bd\u0001\u02be\u0001\u02be\u0001\u02be\u0001\u02be"+ + "\u0003\u02be\u270e\b\u02be\u0001\u02bf\u0001\u02bf\u0003\u02bf\u2712\b"+ + "\u02bf\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001\u02c0\u0001"+ + "\u02c0\u0001\u02c0\u0001\u02c1\u0001\u02c1\u0001\u02c1\u0003\u02c1\u271e"+ + "\b\u02c1\u0003\u02c1\u2720\b\u02c1\u0001\u02c2\u0001\u02c2\u0001\u02c3"+ + "\u0004\u02c3\u2725\b\u02c3\u000b\u02c3\f\u02c3\u2726\u0001\u02c4\u0001"+ + "\u02c4\u0001\u02c4\u0001\u02c4\u0001\u02c5\u0001\u02c5\u0001\u02c5\u0003"+ + "\u02c5\u2730\b\u02c5\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001"+ + "\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001"+ + "\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c6\u0003"+ + "\u02c6\u2742\b\u02c6\u0001\u02c6\u0001\u02c6\u0001\u02c7\u0001\u02c7\u0001"+ + "\u02c7\u0001\u02c7\u0003\u02c7\u274a\b\u02c7\u0001\u02c8\u0001\u02c8\u0001"+ + "\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0001\u02c9\u0003\u02c9\u2753"+ + "\b\u02c9\u0001\u02ca\u0001\u02ca\u0001\u02ca\u0005\u02ca\u2758\b\u02ca"+ + "\n\u02ca\f\u02ca\u275b\t\u02ca\u0001\u02cb\u0001\u02cb\u0001\u02cb\u0001"+ + "\u02cc\u0001\u02cc\u0001\u02cd\u0001\u02cd\u0003\u02cd\u2764\b\u02cd\u0001"+ + "\u02ce\u0001\u02ce\u0001\u02cf\u0001\u02cf\u0003\u02cf\u276a\b\u02cf\u0001"+ + "\u02d0\u0001\u02d0\u0001\u02d1\u0001\u02d1\u0001\u02d1\u0003\u02d1\u2771"+ + "\b\u02d1\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0003\u02d2\u2776\b\u02d2"+ + "\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0003\u02d3\u277c\b\u02d3"+ + "\u0001\u02d4\u0001\u02d4\u0003\u02d4\u2780\b\u02d4\u0001\u02d5\u0001\u02d5"+ + "\u0001\u02d6\u0005\u02d6\u2785\b\u02d6\n\u02d6\f\u02d6\u2788\t\u02d6\u0001"+ + "\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001"+ + "\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001"+ + "\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001"+ + "\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001\u02d7\u0001"+ + "\u02d7\u0001\u02d7\u0001\u02d7\u0003\u02d7\u27a5\b\u02d7\u0001\u02d8\u0001"+ + "\u02d8\u0001\u02d8\u0001\u02d8\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001"+ + "\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001"+ + "\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0001\u02d9\u0003\u02d9\u27b9"+ + "\b\u02d9\u0001\u02da\u0001\u02da\u0003\u02da\u27bd\b\u02da\u0001\u02db"+ + "\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02db\u0001\u02dc\u0001\u02dc"+ + "\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dd\u0001\u02dd"+ + "\u0001\u02dd\u0003\u02dd\u27cd\b\u02dd\u0001\u02de\u0001\u02de\u0001\u02de"+ + "\u0005\u02de\u27d2\b\u02de\n\u02de\f\u02de\u27d5\t\u02de\u0001\u02df\u0001"+ + "\u02df\u0001\u02df\u0001\u02df\u0001\u02e0\u0001\u02e0\u0001\u02e1\u0001"+ + "\u02e1\u0001\u02e2\u0001\u02e2\u0003\u02e2\u27e1\b\u02e2\u0001\u02e2\u0001"+ + "\u02e2\u0001\u02e2\u0001\u02e2\u0005\u02e2\u27e7\b\u02e2\n\u02e2\f\u02e2"+ + "\u27ea\t\u02e2\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3"+ + "\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e3\u0001\u02e4"+ + "\u0001\u02e4\u0001\u02e4\u0001\u02e4\u0001\u02e4\u0005\u02e4\u27fb\b\u02e4"+ + "\n\u02e4\f\u02e4\u27fe\t\u02e4\u0001\u02e5\u0001\u02e5\u0001\u02e5\u0003"+ + "\u02e5\u2803\b\u02e5\u0001\u02e6\u0001\u02e6\u0001\u02e6\u0001\u02e6\u0001"+ + "\u02e6\u0001\u02e6\u0001\u02e6\u0001\u02e6\u0001\u02e7\u0001\u02e7\u0003"+ + "\u02e7\u280f\b\u02e7\u0001\u02e8\u0004\u02e8\u2812\b\u02e8\u000b\u02e8"+ + "\f\u02e8\u2813\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9\u0001\u02e9"+ + "\u0001\u02ea\u0001\u02ea\u0001\u02ea\u0003\u02ea\u281e\b\u02ea\u0001\u02eb"+ + "\u0001\u02eb\u0001\u02eb\u0001\u02ec\u0001\u02ec\u0001\u02ec\u0001\u02ec"+ + "\u0001\u02ec\u0001\u02ed\u0001\u02ed\u0001\u02ed\u0001\u02ed\u0001\u02ed"+ + "\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee"+ + "\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee"+ + "\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0001\u02ee\u0003\u02ee"+ + "\u283e\b\u02ee\u0001\u02ef\u0001\u02ef\u0001\u02ef\u0003\u02ef\u2843\b"+ + "\u02ef\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0001\u02f0\u0005"+ + "\u02f0\u284a\b\u02f0\n\u02f0\f\u02f0\u284d\t\u02f0\u0001\u02f0\u0001\u02f0"+ + "\u0003\u02f0\u2851\b\u02f0\u0001\u02f1\u0001\u02f1\u0003\u02f1\u2855\b"+ + "\u02f1\u0001\u02f2\u0001\u02f2\u0001\u02f2\u0003\u02f2\u285a\b\u02f2\u0001"+ + "\u02f3\u0001\u02f3\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001"+ + "\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f5\u0001"+ + "\u02f5\u0001\u02f5\u0003\u02f5\u286a\b\u02f5\u0001\u02f6\u0001\u02f6\u0001"+ + "\u02f6\u0001\u02f6\u0001\u02f6\u0001\u02f7\u0001\u02f7\u0001\u02f8\u0001"+ + "\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f8\u0001"+ + "\u02f8\u0001\u02f8\u0003\u02f8\u287c\b\u02f8\u0001\u02f8\u0003\u02f8\u287f"+ + "\b\u02f8\u0001\u02f8\u0001\u02f8\u0001\u02f9\u0001\u02f9\u0003\u02f9\u2885"+ + "\b\u02f9\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001"+ + "\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001"+ + "\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001"+ + "\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001\u02fa\u0001"+ + "\u02fa\u0001\u02fa\u0001\u02fa\u0003\u02fa\u28a1\b\u02fa\u0001\u02fb\u0001"+ + "\u02fb\u0001\u02fb\u0001\u02fb\u0001\u02fb\u0001\u02fb\u0001\u02fb\u0001"+ + "\u02fb\u0003\u02fb\u28ab\b\u02fb\u0001\u02fc\u0001\u02fc\u0001\u02fc\u0004"+ + "\u02fc\u28b0\b\u02fc\u000b\u02fc\f\u02fc\u28b1\u0003\u02fc\u28b4\b\u02fc"+ + "\u0001\u02fd\u0001\u02fd\u0001\u02fd\u0003\u02fd\u28b9\b\u02fd\u0001\u02fe"+ + "\u0001\u02fe\u0001\u02fe\u0001\u02fe\u0001\u02ff\u0001\u02ff\u0001\u02ff"+ + "\u0005\u02ff\u28c2\b\u02ff\n\u02ff\f\u02ff\u28c5\t\u02ff\u0001\u0300\u0001"+ + "\u0300\u0001\u0300\u0001\u0300\u0001\u0300\u0001\u0301\u0001\u0301\u0001"+ + "\u0301\u0003\u0301\u28cf\b\u0301\u0001\u0302\u0001\u0302\u0001\u0302\u0001"+ + "\u0302\u0001\u0302\u0001\u0302\u0001\u0302\u0001\u0303\u0001\u0303\u0001"+ + "\u0303\u0001\u0304\u0001\u0304\u0001\u0304\u0001\u0304\u0001\u0304\u0001"+ + "\u0304\u0001\u0304\u0001\u0304\u0001\u0304\u0003\u0304\u28e4\b\u0304\u0001"+ + "\u0304\u0001\u0304\u0001\u0305\u0001\u0305\u0001\u0305\u0003\u0305\u28eb"+ + "\b\u0305\u0001\u0306\u0001\u0306\u0001\u0306\u0005\u0306\u28f0\b\u0306"+ + "\n\u0306\f\u0306\u28f3\t\u0306\u0001\u0307\u0001\u0307\u0001\u0307\u0003"+ + "\u0307\u28f8\b\u0307\u0001\u0307\u0003\u0307\u28fb\b\u0307\u0001\u0308"+ + "\u0001\u0308\u0001\u0308\u0001\u0308\u0001\u0308\u0001\u0308\u0001\u0308"+ + "\u0001\u0308\u0001"; private static final String _serializedATNSegment1 = - "\u0000\u0000\u05cd\u058a\u0001\u0000\u0000\u0000\u05cd\u0591\u0001\u0000"+ - "\u0000\u0000\u05cd\u05a3\u0001\u0000\u0000\u0000\u05cd\u05b3\u0001\u0000"+ - "\u0000\u0000\u05cd\u05c0\u0001\u0000\u0000\u0000\u05ce9\u0001\u0000\u0000"+ - "\u0000\u05cf\u05d0\u0005\u0013\u0000\u0000\u05d0\u05d1\u0005\u01f0\u0000"+ - "\u0000\u05d1\u05d2\u0003\u01d8\u00ec\u0000\u05d2\u05d3\u0005\u0180\u0000"+ - "\u0000\u05d3\u05d4\u0003\u0210\u0108\u0000\u05d4\u05d5\u0005\u01d4\u0000"+ - "\u0000\u05d5\u05d6\u0005\u0247\u0000\u0000\u05d6\u05d7\u0003\u01d8\u00ec"+ - "\u0000\u05d7;\u0001\u0000\u0000\u0000\u05d8\u05d9\u0005\u0013\u0000\u0000"+ - "\u05d9\u05da\u0005\u01f3\u0000\u0000\u05da\u05db\u0003\u0210\u0108\u0000"+ - "\u05db\u05dc\u0005\u01d4\u0000\u0000\u05dc\u05dd\u0005\u0247\u0000\u0000"+ - "\u05dd\u05de\u0003\u0210\u0108\u0000\u05de\u05ea\u0001\u0000\u0000\u0000"+ - "\u05df\u05e0\u0005\u0013\u0000\u0000\u05e0\u05e1\u0005\u01f3\u0000\u0000"+ - "\u05e1\u05e2\u0003\u0210\u0108\u0000\u05e2\u05e3\u0005\u0193\u0000\u0000"+ - "\u05e3\u05e7\u0005\u0247\u0000\u0000\u05e4\u05e8\u0003\u0210\u0108\u0000"+ - "\u05e5\u05e8\u0005\u008d\u0000\u0000\u05e6\u05e8\u0005\u0206\u0000\u0000"+ - "\u05e7\u05e4\u0001\u0000\u0000\u0000\u05e7\u05e5\u0001\u0000\u0000\u0000"+ - "\u05e7\u05e6\u0001\u0000\u0000\u0000\u05e8\u05ea\u0001\u0000\u0000\u0000"+ - "\u05e9\u05d8\u0001\u0000\u0000\u0000\u05e9\u05df\u0001\u0000\u0000\u0000"+ - "\u05ea=\u0001\u0000\u0000\u0000\u05eb\u05ec\u0005\u0013\u0000\u0000\u05ec"+ - "\u05ef\u0005\u0201\u0000\u0000\u05ed\u05ee\u0005\u02b4\u0000\u0000\u05ee"+ - "\u05f0\u0005\u00d3\u0000\u0000\u05ef\u05ed\u0001\u0000\u0000\u0000\u05ef"+ - "\u05f0\u0001\u0000\u0000\u0000\u05f0\u05f1\u0001\u0000\u0000\u0000\u05f1"+ - "\u05f2\u0003\u01d8\u00ec\u0000\u05f2?\u0001\u0000\u0000\u0000\u05f3\u05f5"+ - "\u0007\u0004\u0000\u0000\u05f4\u05f3\u0001\u0000\u0000\u0000\u05f4\u05f5"+ - "\u0001\u0000\u0000\u0000\u05f5\u05f6\u0001\u0000\u0000\u0000\u05f6\u05f8"+ - "\u0003\u0210\u0108\u0000\u05f7\u05f9\u0003\u020a\u0105\u0000\u05f8\u05f7"+ - "\u0001\u0000\u0000\u0000\u05f8\u05f9\u0001\u0000\u0000\u0000\u05f9\u0604"+ - "\u0001\u0000\u0000\u0000\u05fa\u05fc\u0005\u02fa\u0000\u0000\u05fb\u05fd"+ - "\u0007\u0004\u0000\u0000\u05fc\u05fb\u0001\u0000\u0000\u0000\u05fc\u05fd"+ - "\u0001\u0000\u0000\u0000\u05fd\u05fe\u0001\u0000\u0000\u0000\u05fe\u0600"+ - "\u0003\u0210\u0108\u0000\u05ff\u0601\u0003\u020a\u0105\u0000\u0600\u05ff"+ - "\u0001\u0000\u0000\u0000\u0600\u0601\u0001\u0000\u0000\u0000\u0601\u0603"+ - "\u0001\u0000\u0000\u0000\u0602\u05fa\u0001\u0000\u0000\u0000\u0603\u0606"+ - "\u0001\u0000\u0000\u0000\u0604\u0602\u0001\u0000\u0000\u0000\u0604\u0605"+ - "\u0001\u0000\u0000\u0000\u0605A\u0001\u0000\u0000\u0000\u0606\u0604\u0001"+ - "\u0000\u0000\u0000\u0607\u0608\u0005\u0013\u0000\u0000\u0608\u0609\u0005"+ - "\u02be\u0000\u0000\u0609\u0615\u0003\u0210\u0108\u0000\u060a\u060b\u0005"+ - "\u02b9\u0000\u0000\u060b\u0616\u0005\u030a\u0000\u0000\u060c\u060d\u0005"+ - "\u02b9\u0000\u0000\u060d\u060f\u0005\u030a\u0000\u0000\u060e\u060c\u0001"+ - "\u0000\u0000\u0000\u060e\u060f\u0001\u0000\u0000\u0000\u060f\u0610\u0001"+ - "\u0000\u0000\u0000\u0610\u0611\u0005\u0186\u0000\u0000\u0611\u0612\u0005"+ - "\u0300\u0000\u0000\u0612\u0613\u0003@ \u0000\u0613\u0614\u0005\u0301\u0000"+ - "\u0000\u0614\u0616\u0001\u0000\u0000\u0000\u0615\u060a\u0001\u0000\u0000"+ - "\u0000\u0615\u060e\u0001\u0000\u0000\u0000\u0616\u0626\u0001\u0000\u0000"+ - "\u0000\u0617\u0618\u0005\u0013\u0000\u0000\u0618\u0619\u0005\u02be\u0000"+ - "\u0000\u0619\u061a\u0003\u0210\u0108\u0000\u061a\u061b\u0005\u0193\u0000"+ - "\u0000\u061b\u061c\u0005\u0247\u0000\u0000\u061c\u061d\u0003\u0206\u0103"+ - "\u0000\u061d\u0626\u0001\u0000\u0000\u0000\u061e\u061f\u0005\u0013\u0000"+ - "\u0000\u061f\u0620\u0005\u02be\u0000\u0000\u0620\u0621\u0003\u0210\u0108"+ - "\u0000\u0621\u0622\u0005\u01d4\u0000\u0000\u0622\u0623\u0005\u0247\u0000"+ - "\u0000\u0623\u0624\u0003\u01d8\u00ec\u0000\u0624\u0626\u0001\u0000\u0000"+ - "\u0000\u0625\u0607\u0001\u0000\u0000\u0000\u0625\u0617\u0001\u0000\u0000"+ - "\u0000\u0625\u061e\u0001\u0000\u0000\u0000\u0626C\u0001\u0000\u0000\u0000"+ - "\u0627\u0628\u0005\u0013\u0000\u0000\u0628\u0629\u0005\u0224\u0000\u0000"+ - "\u0629\u062a\u0003\u0210\u0108\u0000\u062a\u062b\u0005\u0193\u0000\u0000"+ - "\u062b\u062f\u0005\u0247\u0000\u0000\u062c\u0630\u0003\u0210\u0108\u0000"+ - "\u062d\u0630\u0005\u008d\u0000\u0000\u062e\u0630\u0005\u0206\u0000\u0000"+ - "\u062f\u062c\u0001\u0000\u0000\u0000\u062f\u062d\u0001\u0000\u0000\u0000"+ - "\u062f\u062e\u0001\u0000\u0000\u0000\u0630\u0640\u0001\u0000\u0000\u0000"+ - "\u0631\u0632\u0005\u0013\u0000\u0000\u0632\u0633\u0005\u0224\u0000\u0000"+ - "\u0633\u0634\u0003\u0210\u0108\u0000\u0634\u0635\u0005\u01d4\u0000\u0000"+ - "\u0635\u0636\u0005\u0247\u0000\u0000\u0636\u0637\u0003\u0210\u0108\u0000"+ - "\u0637\u0640\u0001\u0000\u0000\u0000\u0638\u0639\u0005\u0013\u0000\u0000"+ - "\u0639\u063a\u0005\u0224\u0000\u0000\u063a\u063b\u0003\u0210\u0108\u0000"+ - "\u063b\u063c\u0005\u0207\u0000\u0000\u063c\u063d\u0005\u01f3\u0000\u0000"+ - "\u063d\u063e\u0003\u0210\u0108\u0000\u063e\u0640\u0001\u0000\u0000\u0000"+ - "\u063f\u0627\u0001\u0000\u0000\u0000\u063f\u0631\u0001\u0000\u0000\u0000"+ - "\u063f\u0638\u0001\u0000\u0000\u0000\u0640E\u0001\u0000\u0000\u0000\u0641"+ - "\u0642\u0005\u0013\u0000\u0000\u0642\u0643\u0005\u0230\u0000\u0000\u0643"+ - "\u0644\u0003\u0210\u0108\u0000\u0644\u0645\u0005k\u0000\u0000\u0645\u0646"+ - "\u0003\u020a\u0105\u0000\u0646\u0681\u0001\u0000\u0000\u0000\u0647\u0648"+ - "\u0005\u0013\u0000\u0000\u0648\u0649\u0005\u0230\u0000\u0000\u0649\u064a"+ - "\u0003\u0210\u0108\u0000\u064a\u064b\u0005\u0207\u0000\u0000\u064b\u064c"+ - "\u0005\u01ba\u0000\u0000\u064c\u0652\u0003\u01da\u00ed\u0000\u064d\u064e"+ - "\u0005\u0288\u0000\u0000\u064e\u064f\u0005\u0300\u0000\u0000\u064f\u0650"+ - "\u0003\u01e0\u00f0\u0000\u0650\u0651\u0005\u0301\u0000\u0000\u0651\u0653"+ - "\u0001\u0000\u0000\u0000\u0652\u064d\u0001\u0000\u0000\u0000\u0652\u0653"+ - "\u0001\u0000\u0000\u0000\u0653\u0681\u0001\u0000\u0000\u0000\u0654\u0655"+ - "\u0005\u0013\u0000\u0000\u0655\u0656\u0005\u0230\u0000\u0000\u0656\u0657"+ - "\u0003\u0210\u0108\u0000\u0657\u0658\u0005\u01c7\u0000\u0000\u0658\u065e"+ - "\u0005\u01ba\u0000\u0000\u0659\u065a\u0005\u0288\u0000\u0000\u065a\u065b"+ - "\u0005\u0300\u0000\u0000\u065b\u065c\u0003\u01e0\u00f0\u0000\u065c\u065d"+ - "\u0005\u0301\u0000\u0000\u065d\u065f\u0001\u0000\u0000\u0000\u065e\u0659"+ - "\u0001\u0000\u0000\u0000\u065e\u065f\u0001\u0000\u0000\u0000\u065f\u0681"+ - "\u0001\u0000\u0000\u0000\u0660\u0661\u0005\u0013\u0000\u0000\u0661\u0662"+ - "\u0005\u0230\u0000\u0000\u0662\u0663\u0003\u0210\u0108\u0000\u0663\u0664"+ - "\u0005\u00c3\u0000\u0000\u0664\u0681\u0001\u0000\u0000\u0000\u0665\u0666"+ - "\u0005\u0013\u0000\u0000\u0666\u0667\u0005\u0230\u0000\u0000\u0667\u0668"+ - "\u0003\u0210\u0108\u0000\u0668\u0669\u0005\u00b3\u0000\u0000\u0669\u0681"+ - "\u0001\u0000\u0000\u0000\u066a\u066b\u0005\u0013\u0000\u0000\u066b\u066c"+ - "\u0005\u0230\u0000\u0000\u066c\u066d\u0003\u0210\u0108\u0000\u066d\u066e"+ - "\u0005\u0207\u0000\u0000\u066e\u066f\u0005\u0300\u0000\u0000\u066f\u0670"+ - "\u0003\u01e0\u00f0\u0000\u0670\u0671\u0005\u0301\u0000\u0000\u0671\u0681"+ - "\u0001\u0000\u0000\u0000\u0672\u0673\u0005\u0013\u0000\u0000\u0673\u0674"+ - "\u0005\u0230\u0000\u0000\u0674\u0675\u0003\u0210\u0108\u0000\u0675\u0676"+ - "\u0005\u0193\u0000\u0000\u0676\u0677\u0005\u0247\u0000\u0000\u0677\u0678"+ - "\u0003\u0206\u0103\u0000\u0678\u0681\u0001\u0000\u0000\u0000\u0679\u067a"+ - "\u0005\u0013\u0000\u0000\u067a\u067b\u0005\u0230\u0000\u0000\u067b\u067c"+ - "\u0003\u0210\u0108\u0000\u067c\u067d\u0005\u01d4\u0000\u0000\u067d\u067e"+ - "\u0005\u0247\u0000\u0000\u067e\u067f\u0003\u0210\u0108\u0000\u067f\u0681"+ - "\u0001\u0000\u0000\u0000\u0680\u0641\u0001\u0000\u0000\u0000\u0680\u0647"+ - "\u0001\u0000\u0000\u0000\u0680\u0654\u0001\u0000\u0000\u0000\u0680\u0660"+ - "\u0001\u0000\u0000\u0000\u0680\u0665\u0001\u0000\u0000\u0000\u0680\u066a"+ - "\u0001\u0000\u0000\u0000\u0680\u0672\u0001\u0000\u0000\u0000\u0680\u0679"+ - "\u0001\u0000\u0000\u0000\u0681G\u0001\u0000\u0000\u0000\u0682\u0683\u0005"+ - "\u0013\u0000\u0000\u0683\u0684\u0005\u0235\u0000\u0000\u0684\u0685\u0005"+ - "\u0207\u0000\u0000\u0685\u0686\u0005\u030c\u0000\u0000\u0686\u0687\u0007"+ - "\u0005\u0000\u0000\u0687\u0691\u0003\u020a\u0105\u0000\u0688\u0689\u0005"+ - "\u0013\u0000\u0000\u0689\u068a\u0005\u0235\u0000\u0000\u068a\u068b\u0005"+ - "\u01d8\u0000\u0000\u068b\u0691\u0005\u030c\u0000\u0000\u068c\u068d\u0005"+ - "\u0013\u0000\u0000\u068d\u068e\u0005\u0235\u0000\u0000\u068e\u068f\u0005"+ - "\u01d8\u0000\u0000\u068f\u0691\u0005\u0010\u0000\u0000\u0690\u0682\u0001"+ - "\u0000\u0000\u0000\u0690\u0688\u0001\u0000\u0000\u0000\u0690\u068c\u0001"+ - "\u0000\u0000\u0000\u0691I\u0001\u0000\u0000\u0000\u0692\u0693\u0003\u0214"+ - "\u010a\u0000\u0693K\u0001\u0000\u0000\u0000\u0694\u0695\u0005\u0013\u0000"+ - "\u0000\u0695\u0696\u0005\u023a\u0000\u0000\u0696\u0697\u0003\u0210\u0108"+ - "\u0000\u0697\u0698\u0005\u01d4\u0000\u0000\u0698\u0699\u0005\u0247\u0000"+ - "\u0000\u0699\u069a\u0003\u0210\u0108\u0000\u069a\u06b6\u0001\u0000\u0000"+ - "\u0000\u069b\u069c\u0005\u0013\u0000\u0000\u069c\u069d\u0005\u023a\u0000"+ - "\u0000\u069d\u069e\u0003\u0210\u0108\u0000\u069e\u069f\u0005\u0193\u0000"+ - "\u0000\u069f\u06a3\u0005\u0247\u0000\u0000\u06a0\u06a4\u0003\u0210\u0108"+ - "\u0000\u06a1\u06a4\u0005\u008d\u0000\u0000\u06a2\u06a4\u0005\u0206\u0000"+ - "\u0000\u06a3\u06a0\u0001\u0000\u0000\u0000\u06a3\u06a1\u0001\u0000\u0000"+ - "\u0000\u06a3\u06a2\u0001\u0000\u0000\u0000\u06a4\u06b6\u0001\u0000\u0000"+ - "\u0000\u06a5\u06a6\u0005\u0013\u0000\u0000\u06a6\u06a7\u0005\u023a\u0000"+ - "\u0000\u06a7\u06a8\u0003\u0210\u0108\u0000\u06a8\u06a9\u0005\u0207\u0000"+ - "\u0000\u06a9\u06aa\u0005\u0300\u0000\u0000\u06aa\u06ab\u0003\u01e0\u00f0"+ - "\u0000\u06ab\u06ac\u0005\u0301\u0000\u0000\u06ac\u06b6\u0001\u0000\u0000"+ - "\u0000\u06ad\u06ae\u0005\u0013\u0000\u0000\u06ae\u06af\u0005\u023a\u0000"+ - "\u0000\u06af\u06b0\u0003\u0210\u0108\u0000\u06b0\u06b1\u0005\u01d8\u0000"+ - "\u0000\u06b1\u06b2\u0005\u0300\u0000\u0000\u06b2\u06b3\u0003\u01dc\u00ee"+ - "\u0000\u06b3\u06b4\u0005\u0301\u0000\u0000\u06b4\u06b6\u0001\u0000\u0000"+ - "\u0000\u06b5\u0694\u0001\u0000\u0000\u0000\u06b5\u069b\u0001\u0000\u0000"+ - "\u0000\u06b5\u06a5\u0001\u0000\u0000\u0000\u06b5\u06ad\u0001\u0000\u0000"+ - "\u0000\u06b6M\u0001\u0000\u0000\u0000\u06b7\u06b8\u0005\u0013\u0000\u0000"+ - "\u06b8\u06b9\u0005\u02f1\u0000\u0000\u06b9\u06ba\u0005\u01fa\u0000\u0000"+ - "\u06ba\u06bb\u0005h\u0000\u0000\u06bb\u06bc\u0003\u0210\u0108\u0000\u06bc"+ - "\u06bd\u0005\u000b\u0000\u0000\u06bd\u06be\u0005\u0145\u0000\u0000\u06be"+ - "\u06bf\u0005\u00e3\u0000\u0000\u06bf\u06c0\u0003\u01dc\u00ee\u0000\u06c0"+ - "\u06c1\u0005\u0288\u0000\u0000\u06c1\u06c2\u0003\u01dc\u00ee\u0000\u06c2"+ - "\u0713\u0001\u0000\u0000\u0000\u06c3\u06c4\u0005\u0013\u0000\u0000\u06c4"+ - "\u06c5\u0005\u02f1\u0000\u0000\u06c5\u06c6\u0005\u01fa\u0000\u0000\u06c6"+ - "\u06c7\u0005h\u0000\u0000\u06c7\u06c8\u0003\u0210\u0108\u0000\u06c8\u06c9"+ - "\u0005\u0013\u0000\u0000\u06c9\u06ca\u0005\u0145\u0000\u0000\u06ca\u06cb"+ - "\u0005\u00e3\u0000\u0000\u06cb\u06cc\u0003\u01dc\u00ee\u0000\u06cc\u06cd"+ - "\u0005\u0288\u0000\u0000\u06cd\u06ce\u0003\u01dc\u00ee\u0000\u06ce\u0713"+ - "\u0001\u0000\u0000\u0000\u06cf\u06d0\u0005\u0013\u0000\u0000\u06d0\u06d1"+ - "\u0005\u02f1\u0000\u0000\u06d1\u06d2\u0005\u01fa\u0000\u0000\u06d2\u06d3"+ - "\u0005h\u0000\u0000\u06d3\u06d4\u0003\u0210\u0108\u0000\u06d4\u06d5\u0005"+ - "\u0013\u0000\u0000\u06d5\u06d6\u0005\u0145\u0000\u0000\u06d6\u06d7\u0005"+ - "\u01d6\u0000\u0000\u06d7\u06d8\u0003\u0210\u0108\u0000\u06d8\u06d9\u0005"+ - "\u0288\u0000\u0000\u06d9\u06da\u0003\u0210\u0108\u0000\u06da\u0713\u0001"+ - "\u0000\u0000\u0000\u06db\u06dc\u0005\u0013\u0000\u0000\u06dc\u06dd\u0005"+ - "\u02f1\u0000\u0000\u06dd\u06de\u0005\u01fa\u0000\u0000\u06de\u06df\u0005"+ - "h\u0000\u0000\u06df\u06e0\u0003\u0210\u0108\u0000\u06e0\u06e1\u0005\u0013"+ - "\u0000\u0000\u06e1\u06e2\u0005\u0145\u0000\u0000\u06e2\u06e3\u0005\u00e3"+ - "\u0000\u0000\u06e3\u06e4\u0003\u01dc\u00ee\u0000\u06e4\u06e5\u0005\u01d6"+ - "\u0000\u0000\u06e5\u06e6\u0003\u0210\u0108\u0000\u06e6\u06e7\u0005\u0288"+ - "\u0000\u0000\u06e7\u06e8\u0003\u0210\u0108\u0000\u06e8\u0713\u0001\u0000"+ - "\u0000\u0000\u06e9\u06ea\u0005\u0013\u0000\u0000\u06ea\u06eb\u0005\u02f1"+ - "\u0000\u0000\u06eb\u06ec\u0005\u01fa\u0000\u0000\u06ec\u06ed\u0005h\u0000"+ - "\u0000\u06ed\u06ee\u0003\u0210\u0108\u0000\u06ee\u06ef\u0005\u00bc\u0000"+ - "\u0000\u06ef\u06f2\u0005\u0145\u0000\u0000\u06f0\u06f1\u0005\u02b4\u0000"+ - "\u0000\u06f1\u06f3\u0005\u00d3\u0000\u0000\u06f2\u06f0\u0001\u0000\u0000"+ - "\u0000\u06f2\u06f3\u0001\u0000\u0000\u0000\u06f3\u06f4\u0001\u0000\u0000"+ - "\u0000\u06f4\u06f5\u0005\u00e3\u0000\u0000\u06f5\u06f6\u0003\u01dc\u00ee"+ - "\u0000\u06f6\u0713\u0001\u0000\u0000\u0000\u06f7\u06f8\u0005\u0013\u0000"+ - "\u0000\u06f8\u06f9\u0005\u02f1\u0000\u0000\u06f9\u06fa\u0005\u01fa\u0000"+ - "\u0000\u06fa\u06fb\u0005h\u0000\u0000\u06fb\u06fc\u0003\u0210\u0108\u0000"+ - "\u06fc\u06fd\u0005\u01d4\u0000\u0000\u06fd\u06fe\u0005\u0247\u0000\u0000"+ - "\u06fe\u06ff\u0003\u0210\u0108\u0000\u06ff\u0713\u0001\u0000\u0000\u0000"+ - "\u0700\u0701\u0005\u0013\u0000\u0000\u0701\u0702\u0005\u02f1\u0000\u0000"+ - "\u0702\u0703\u0005\u01fa\u0000\u0000\u0703\u0704\u0005h\u0000\u0000\u0704"+ - "\u0705\u0003\u0210\u0108\u0000\u0705\u0706\u0005\u0193\u0000\u0000\u0706"+ - "\u0707\u0005\u0247\u0000\u0000\u0707\u0708\u0003\u0206\u0103\u0000\u0708"+ - "\u0713\u0001\u0000\u0000\u0000\u0709\u070a\u0005\u0013\u0000\u0000\u070a"+ - "\u070b\u0005\u02f1\u0000\u0000\u070b\u070c\u0005\u01fa\u0000\u0000\u070c"+ - "\u070d\u0005h\u0000\u0000\u070d\u070e\u0003\u0210\u0108\u0000\u070e\u070f"+ - "\u0005\u0207\u0000\u0000\u070f\u0710\u0005\u01f3\u0000\u0000\u0710\u0711"+ - "\u0003\u0210\u0108\u0000\u0711\u0713\u0001\u0000\u0000\u0000\u0712\u06b7"+ - "\u0001\u0000\u0000\u0000\u0712\u06c3\u0001\u0000\u0000\u0000\u0712\u06cf"+ - "\u0001\u0000\u0000\u0000\u0712\u06db\u0001\u0000\u0000\u0000\u0712\u06e9"+ - "\u0001\u0000\u0000\u0000\u0712\u06f7\u0001\u0000\u0000\u0000\u0712\u0700"+ - "\u0001\u0000\u0000\u0000\u0712\u0709\u0001\u0000\u0000\u0000\u0713O\u0001"+ - "\u0000\u0000\u0000\u0714\u0715\u0003\u0214\u010a\u0000\u0715Q\u0001\u0000"+ - "\u0000\u0000\u0716\u0717\u0003\u0214\u010a\u0000\u0717S\u0001\u0000\u0000"+ - "\u0000\u0718\u0719\u0005\u0013\u0000\u0000\u0719\u071a\u0005\u02f1\u0000"+ - "\u0000\u071a\u071b\u0005\u01fa\u0000\u0000\u071b\u071c\u0005\u023c\u0000"+ - "\u0000\u071c\u071d\u0003\u0210\u0108\u0000\u071d\u071e\u0005\u01d4\u0000"+ - "\u0000\u071e\u071f\u0005\u0247\u0000\u0000\u071f\u0720\u0003\u0210\u0108"+ - "\u0000\u0720\u072b\u0001\u0000\u0000\u0000\u0721\u0722\u0005\u0013\u0000"+ - "\u0000\u0722\u0723\u0005\u02f1\u0000\u0000\u0723\u0724\u0005\u01fa\u0000"+ - "\u0000\u0724\u0725\u0005\u023c\u0000\u0000\u0725\u0726\u0003\u0210\u0108"+ - "\u0000\u0726\u0727\u0005\u0207\u0000\u0000\u0727\u0728\u0005\u01f3\u0000"+ - "\u0000\u0728\u0729\u0003\u0210\u0108\u0000\u0729\u072b\u0001\u0000\u0000"+ - "\u0000\u072a\u0718\u0001\u0000\u0000\u0000\u072a\u0721\u0001\u0000\u0000"+ - "\u0000\u072bU\u0001\u0000\u0000\u0000\u072c\u072d\u0005\u0013\u0000\u0000"+ - "\u072d\u072e\u0005\u0255\u0000\u0000\u072e\u072f\u0003\u0210\u0108\u0000"+ - "\u072f\u0730\u0005\u0180\u0000\u0000\u0730\u0731\u0003\u0210\u0108\u0000"+ - "\u0731\u0732\u0005\u01d4\u0000\u0000\u0732\u0733\u0005\u0247\u0000\u0000"+ - "\u0733\u0734\u0003\u0210\u0108\u0000\u0734\u0740\u0001\u0000\u0000\u0000"+ - "\u0735\u0736\u0005\u0013\u0000\u0000\u0736\u0737\u0005\u0255\u0000\u0000"+ - "\u0737\u0738\u0003\u0210\u0108\u0000\u0738\u0739\u0005\u0180\u0000\u0000"+ - "\u0739\u073a\u0003\u0210\u0108\u0000\u073a\u073b\u0005\u00a7\u0000\u0000"+ - "\u073b\u073c\u0005\u0180\u0000\u0000\u073c\u073d\u0005\u00d7\u0000\u0000"+ - "\u073d\u073e\u0003\u0210\u0108\u0000\u073e\u0740\u0001\u0000\u0000\u0000"+ - "\u073f\u072c\u0001\u0000\u0000\u0000\u073f\u0735\u0001\u0000\u0000\u0000"+ - "\u0740W\u0001\u0000\u0000\u0000\u0741\u0742\u0003\u0214\u010a\u0000\u0742"+ - "Y\u0001\u0000\u0000\u0000\u0743\u0744\u0003\u0214\u010a\u0000\u0744[\u0001"+ - "\u0000\u0000\u0000\u0745\u0746\u0005\u0013\u0000\u0000\u0746\u0747\u0005"+ - "\u026e\u0000\u0000\u0747\u0748\u0005\u0145\u0000\u0000\u0748\u0749\u0005"+ - "\u00e3\u0000\u0000\u0749\u074a\u0003\u0206\u0103\u0000\u074a\u074b\u0005"+ - "\u02be\u0000\u0000\u074b\u074c\u0003\u0210\u0108\u0000\u074c\u074d\u0005"+ - "\u0186\u0000\u0000\u074d\u074e\u0005\u0300\u0000\u0000\u074e\u074f\u0003"+ - "@ \u0000\u074f\u0750\u0005\u0301\u0000\u0000\u0750]\u0001\u0000\u0000"+ - "\u0000\u0751\u0752\u0003\u0214\u010a\u0000\u0752_\u0001\u0000\u0000\u0000"+ - "\u0753\u0755\u0005\u0016\u0000\u0000\u0754\u0756\u0005\u0280\u0000\u0000"+ - "\u0755\u0754\u0001\u0000\u0000\u0000\u0755\u0756\u0001\u0000\u0000\u0000"+ - "\u0756\u0757\u0001\u0000\u0000\u0000\u0757\u075c\u0003\u01e2\u00f1\u0000"+ - "\u0758\u0759\u0005\u0300\u0000\u0000\u0759\u075a\u0003\u01da\u00ed\u0000"+ - "\u075a\u075b\u0005\u0301\u0000\u0000\u075b\u075d\u0001\u0000\u0000\u0000"+ - "\u075c\u0758\u0001\u0000\u0000\u0000\u075c\u075d\u0001\u0000\u0000\u0000"+ - "\u075da\u0001\u0000\u0000\u0000\u075e\u075f\u0003\u0214\u010a\u0000\u075f"+ - "c\u0001\u0000\u0000\u0000\u0760\u0761\u0003\u0214\u010a\u0000\u0761e\u0001"+ - "\u0000\u0000\u0000\u0762\u0763\u0003\u0214\u010a\u0000\u0763g\u0001\u0000"+ - "\u0000\u0000\u0764\u0765\u0003\u0214\u010a\u0000\u0765i\u0001\u0000\u0000"+ - "\u0000\u0766\u0767\u0003\u0214\u010a\u0000\u0767k\u0001\u0000\u0000\u0000"+ - "\u0768\u0769\u0003\u0214\u010a\u0000\u0769m\u0001\u0000\u0000\u0000\u076a"+ - "\u0792\u0003p8\u0000\u076b\u0792\u0003r9\u0000\u076c\u0792\u0003t:\u0000"+ - "\u076d\u0792\u0003z=\u0000\u076e\u0792\u0003|>\u0000\u076f\u0792\u0003"+ - "~?\u0000\u0770\u0792\u0003\u0082A\u0000\u0771\u0792\u0003\u0086C\u0000"+ - "\u0772\u0792\u0003\u008aE\u0000\u0773\u0792\u0003\u008cF\u0000\u0774\u0792"+ - "\u0003\u008eG\u0000\u0775\u0792\u0003\u0090H\u0000\u0776\u0792\u0003\u0092"+ - "I\u0000\u0777\u0792\u0003\u0094J\u0000\u0778\u0792\u0003\u0096K\u0000"+ - "\u0779\u0792\u0003\u0098L\u0000\u077a\u0792\u0003\u009cN\u0000\u077b\u0792"+ - "\u0003\u009eO\u0000\u077c\u0792\u0003\u00a0P\u0000\u077d\u0792\u0003\u00a2"+ - "Q\u0000\u077e\u0792\u0003\u00a6S\u0000\u077f\u0792\u0003\u00a8T\u0000"+ - "\u0780\u0792\u0003\u00aaU\u0000\u0781\u0792\u0003\u00acV\u0000\u0782\u0792"+ - "\u0003\u00aeW\u0000\u0783\u0792\u0003\u00b0X\u0000\u0784\u0792\u0003\u00b2"+ - "Y\u0000\u0785\u0792\u0003\u00b4Z\u0000\u0786\u0792\u0003\u00b6[\u0000"+ - "\u0787\u0792\u0003\u00b8\\\u0000\u0788\u0792\u0003\u00ba]\u0000\u0789"+ - "\u0792\u0003\u00bc^\u0000\u078a\u0792\u0003\u00be_\u0000\u078b\u0792\u0003"+ - "\u00c0`\u0000\u078c\u0792\u0003\u00c2a\u0000\u078d\u0792\u0003\u00c4b"+ - "\u0000\u078e\u0792\u0003\u00c6c\u0000\u078f\u0792\u0003\u00c8d\u0000\u0790"+ - "\u0792\u0003\u00cae\u0000\u0791\u076a\u0001\u0000\u0000\u0000\u0791\u076b"+ - "\u0001\u0000\u0000\u0000\u0791\u076c\u0001\u0000\u0000\u0000\u0791\u076d"+ - "\u0001\u0000\u0000\u0000\u0791\u076e\u0001\u0000\u0000\u0000\u0791\u076f"+ - "\u0001\u0000\u0000\u0000\u0791\u0770\u0001\u0000\u0000\u0000\u0791\u0771"+ - "\u0001\u0000\u0000\u0000\u0791\u0772\u0001\u0000\u0000\u0000\u0791\u0773"+ - "\u0001\u0000\u0000\u0000\u0791\u0774\u0001\u0000\u0000\u0000\u0791\u0775"+ - "\u0001\u0000\u0000\u0000\u0791\u0776\u0001\u0000\u0000\u0000\u0791\u0777"+ - "\u0001\u0000\u0000\u0000\u0791\u0778\u0001\u0000\u0000\u0000\u0791\u0779"+ - "\u0001\u0000\u0000\u0000\u0791\u077a\u0001\u0000\u0000\u0000\u0791\u077b"+ - "\u0001\u0000\u0000\u0000\u0791\u077c\u0001\u0000\u0000\u0000\u0791\u077d"+ - "\u0001\u0000\u0000\u0000\u0791\u077e\u0001\u0000\u0000\u0000\u0791\u077f"+ - "\u0001\u0000\u0000\u0000\u0791\u0780\u0001\u0000\u0000\u0000\u0791\u0781"+ - "\u0001\u0000\u0000\u0000\u0791\u0782\u0001\u0000\u0000\u0000\u0791\u0783"+ - "\u0001\u0000\u0000\u0000\u0791\u0784\u0001\u0000\u0000\u0000\u0791\u0785"+ - "\u0001\u0000\u0000\u0000\u0791\u0786\u0001\u0000\u0000\u0000\u0791\u0787"+ - "\u0001\u0000\u0000\u0000\u0791\u0788\u0001\u0000\u0000\u0000\u0791\u0789"+ - "\u0001\u0000\u0000\u0000\u0791\u078a\u0001\u0000\u0000\u0000\u0791\u078b"+ - "\u0001\u0000\u0000\u0000\u0791\u078c\u0001\u0000\u0000\u0000\u0791\u078d"+ - "\u0001\u0000\u0000\u0000\u0791\u078e\u0001\u0000\u0000\u0000\u0791\u078f"+ - "\u0001\u0000\u0000\u0000\u0791\u0790\u0001\u0000\u0000\u0000\u0792o\u0001"+ - "\u0000\u0000\u0000\u0793\u0794\u0005~\u0000\u0000\u0794\u0795\u0005\b"+ - "\u0000\u0000\u0795\u0796\u0005\u0150\u0000\u0000\u0796\u0797\u0003\u01d8"+ - "\u00ec\u0000\u0797\u0798\u0005\u025d\u0000\u0000\u0798\u0799\u0005\u010c"+ - "\u0000\u0000\u0799\u079a\u0005\u00fc\u0000\u0000\u079a\u079b\u0003\u01d8"+ - "\u00ec\u0000\u079bq\u0001\u0000\u0000\u0000\u079c\u079d\u0005~\u0000\u0000"+ - "\u079d\u079e\u0005\u000e\u0000\u0000\u079e\u079f\u0003\u01d8\u00ec\u0000"+ - "\u079f\u07a1\u0005\u0300\u0000\u0000\u07a0\u07a2\u0007\u0006\u0000\u0000"+ - "\u07a1\u07a0\u0001\u0000\u0000\u0000\u07a1\u07a2\u0001\u0000\u0000\u0000"+ - "\u07a2\u07a4\u0001\u0000\u0000\u0000\u07a3\u07a5\u0003\u01d8\u00ec\u0000"+ - "\u07a4\u07a3\u0001\u0000\u0000\u0000\u07a4\u07a5\u0001\u0000\u0000\u0000"+ - "\u07a5\u07a6\u0001\u0000\u0000\u0000\u07a6\u07a7\u0003\u01e6\u00f3\u0000"+ - "\u07a7\u07a8\u0005\u0301\u0000\u0000\u07a8\u07a9\u0005\u0300\u0000\u0000"+ - "\u07a9\u07aa\u0005\u029d\u0000\u0000\u07aa\u07ab\u0005\u0319\u0000\u0000"+ - "\u07ab\u07ac\u0003\u0210\u0108\u0000\u07ac\u07ad\u0005\u02fa\u0000\u0000"+ - "\u07ad\u07ae\u0005\u029e\u0000\u0000\u07ae\u07af\u0005\u0319\u0000\u0000"+ - "\u07af\u07b4\u0003\u0210\u0108\u0000\u07b0\u07b1\u0005\u02fa\u0000\u0000"+ - "\u07b1\u07b2\u0005\u029f\u0000\u0000\u07b2\u07b3\u0005\u0319\u0000\u0000"+ - "\u07b3\u07b5\u0005\u0307\u0000\u0000\u07b4\u07b0\u0001\u0000\u0000\u0000"+ - "\u07b4\u07b5\u0001\u0000\u0000\u0000\u07b5\u07ba\u0001\u0000\u0000\u0000"+ - "\u07b6\u07b7\u0005\u02fa\u0000\u0000\u07b7\u07b8\u0005\u02a0\u0000\u0000"+ - "\u07b8\u07b9\u0005\u0319\u0000\u0000\u07b9\u07bb\u0003\u0210\u0108\u0000"+ - "\u07ba\u07b6\u0001\u0000\u0000\u0000\u07ba\u07bb\u0001\u0000\u0000\u0000"+ - "\u07bb\u07be\u0001\u0000\u0000\u0000\u07bc\u07bd\u0005\u02fa\u0000\u0000"+ - "\u07bd\u07bf\u0005\u02a1\u0000\u0000\u07be\u07bc\u0001\u0000\u0000\u0000"+ - "\u07be\u07bf\u0001\u0000\u0000\u0000\u07bf\u07c4\u0001\u0000\u0000\u0000"+ - "\u07c0\u07c1\u0005\u02fa\u0000\u0000\u07c1\u07c2\u0005\u02a2\u0000\u0000"+ - "\u07c2\u07c3\u0005\u0319\u0000\u0000\u07c3\u07c5\u0003\u0210\u0108\u0000"+ - "\u07c4\u07c0\u0001\u0000\u0000\u0000\u07c4\u07c5\u0001\u0000\u0000\u0000"+ - "\u07c5\u07ca\u0001\u0000\u0000\u0000\u07c6\u07c7\u0005\u02fa\u0000\u0000"+ - "\u07c7\u07c8\u0005\u02a3\u0000\u0000\u07c8\u07c9\u0005\u0319\u0000\u0000"+ - "\u07c9\u07cb\u0003\u0210\u0108\u0000\u07ca\u07c6\u0001\u0000\u0000\u0000"+ - "\u07ca\u07cb\u0001\u0000\u0000\u0000\u07cb\u07d0\u0001\u0000\u0000\u0000"+ - "\u07cc\u07cd\u0005\u02fa\u0000\u0000\u07cd\u07ce\u0005\u02a4\u0000\u0000"+ - "\u07ce\u07cf\u0005\u0319\u0000\u0000\u07cf\u07d1\u0003\u0210\u0108\u0000"+ - "\u07d0\u07cc\u0001\u0000\u0000\u0000\u07d0\u07d1\u0001\u0000\u0000\u0000"+ - "\u07d1\u07d6\u0001\u0000\u0000\u0000\u07d2\u07d3\u0005\u02fa\u0000\u0000"+ - "\u07d3\u07d4\u0005\u02a5\u0000\u0000\u07d4\u07d5\u0005\u0319\u0000\u0000"+ - "\u07d5\u07d7\u0003\u01b8\u00dc\u0000\u07d6\u07d2\u0001\u0000\u0000\u0000"+ - "\u07d6\u07d7\u0001\u0000\u0000\u0000\u07d7\u07dc\u0001\u0000\u0000\u0000"+ - "\u07d8\u07d9\u0005\u02fa\u0000\u0000\u07d9\u07da\u0005\u02a6\u0000\u0000"+ - "\u07da\u07db\u0005\u0319\u0000\u0000\u07db\u07dd\u0003\u0210\u0108\u0000"+ - "\u07dc\u07d8\u0001\u0000\u0000\u0000\u07dc\u07dd\u0001\u0000\u0000\u0000"+ - "\u07dd\u07e2\u0001\u0000\u0000\u0000\u07de\u07df\u0005\u02fa\u0000\u0000"+ - "\u07df\u07e0\u0005\u02a7\u0000\u0000\u07e0\u07e1\u0005\u0319\u0000\u0000"+ - "\u07e1\u07e3\u0003\u0210\u0108\u0000\u07e2\u07de\u0001\u0000\u0000\u0000"+ - "\u07e2\u07e3\u0001\u0000\u0000\u0000\u07e3\u07e8\u0001\u0000\u0000\u0000"+ - "\u07e4\u07e5\u0005\u02fa\u0000\u0000\u07e5\u07e6\u0005\u02a8\u0000\u0000"+ - "\u07e6\u07e7\u0005\u0319\u0000\u0000\u07e7\u07e9\u0003\u0210\u0108\u0000"+ - "\u07e8\u07e4\u0001\u0000\u0000\u0000\u07e8\u07e9\u0001\u0000\u0000\u0000"+ - "\u07e9\u07ee\u0001\u0000\u0000\u0000\u07ea\u07eb\u0005\u02fa\u0000\u0000"+ - "\u07eb\u07ec\u0005\u02a9\u0000\u0000\u07ec\u07ed\u0005\u0319\u0000\u0000"+ - "\u07ed\u07ef\u0005\u0307\u0000\u0000\u07ee\u07ea\u0001\u0000\u0000\u0000"+ - "\u07ee\u07ef\u0001\u0000\u0000\u0000\u07ef\u07f4\u0001\u0000\u0000\u0000"+ - "\u07f0\u07f1\u0005\u02fa\u0000\u0000\u07f1\u07f2\u0005\u02aa\u0000\u0000"+ - "\u07f2\u07f3\u0005\u0319\u0000\u0000\u07f3\u07f5\u0003\u0210\u0108\u0000"+ - "\u07f4\u07f0\u0001\u0000\u0000\u0000\u07f4\u07f5\u0001\u0000\u0000\u0000"+ - "\u07f5\u07f8\u0001\u0000\u0000\u0000\u07f6\u07f7\u0005\u02fa\u0000\u0000"+ - "\u07f7\u07f9\u0005\u02ab\u0000\u0000\u07f8\u07f6\u0001\u0000\u0000\u0000"+ - "\u07f8\u07f9\u0001\u0000\u0000\u0000\u07f9\u07fe\u0001\u0000\u0000\u0000"+ - "\u07fa\u07fb\u0005\u02fa\u0000\u0000\u07fb\u07fc\u0005\u02ac\u0000\u0000"+ - "\u07fc\u07fd\u0005\u0319\u0000\u0000\u07fd\u07ff\u0003\u0210\u0108\u0000"+ - "\u07fe\u07fa\u0001\u0000\u0000\u0000\u07fe\u07ff\u0001\u0000\u0000\u0000"+ - "\u07ff\u0804\u0001\u0000\u0000\u0000\u0800\u0801\u0005\u02fa\u0000\u0000"+ - "\u0801\u0802\u0005\u02ad\u0000\u0000\u0802\u0803\u0005\u0319\u0000\u0000"+ - "\u0803\u0805\u0003\u0210\u0108\u0000\u0804\u0800\u0001\u0000\u0000\u0000"+ - "\u0804\u0805\u0001\u0000\u0000\u0000\u0805\u080a\u0001\u0000\u0000\u0000"+ - "\u0806\u0807\u0005\u02fa\u0000\u0000\u0807\u0808\u0005\u02ae\u0000\u0000"+ - "\u0808\u0809\u0005\u0319\u0000\u0000\u0809\u080b\u0007\u0007\u0000\u0000"+ - "\u080a\u0806\u0001\u0000\u0000\u0000\u080a\u080b\u0001\u0000\u0000\u0000"+ - "\u080b\u080c\u0001\u0000\u0000\u0000\u080c\u080d\u0005\u0301\u0000\u0000"+ - "\u080d\u08b7\u0001\u0000\u0000\u0000\u080e\u080f\u0005~\u0000\u0000\u080f"+ - "\u0810\u0005\u000e\u0000\u0000\u0810\u0811\u0003\u01d8\u00ec\u0000\u0811"+ - "\u0819\u0005\u0300\u0000\u0000\u0812\u0814\u0007\u0006\u0000\u0000\u0813"+ - "\u0812\u0001\u0000\u0000\u0000\u0813\u0814\u0001\u0000\u0000\u0000\u0814"+ - "\u0816\u0001\u0000\u0000\u0000\u0815\u0817\u0003\u01d8\u00ec\u0000\u0816"+ - "\u0815\u0001\u0000\u0000\u0000\u0816\u0817\u0001\u0000\u0000\u0000\u0817"+ - "\u0818\u0001\u0000\u0000\u0000\u0818\u081a\u0003\u01e6\u00f3\u0000\u0819"+ - "\u0813\u0001\u0000\u0000\u0000\u0819\u081a\u0001\u0000\u0000\u0000\u081a"+ - "\u081b\u0001\u0000\u0000\u0000\u081b\u081c\u0005\u0188\u0000\u0000\u081c"+ - "\u081e\u00056\u0000\u0000\u081d\u081f\u0007\u0006\u0000\u0000\u081e\u081d"+ - "\u0001\u0000\u0000\u0000\u081e\u081f\u0001\u0000\u0000\u0000\u081f\u0821"+ - "\u0001\u0000\u0000\u0000\u0820\u0822\u0003\u01d8\u00ec\u0000\u0821\u0820"+ - "\u0001\u0000\u0000\u0000\u0821\u0822\u0001\u0000\u0000\u0000\u0822\u0823"+ - "\u0001\u0000\u0000\u0000\u0823\u0824\u0003\u01e6\u00f3\u0000\u0824\u0825"+ - "\u0005\u0301\u0000\u0000\u0825\u0826\u0005\u0300\u0000\u0000\u0826\u0827"+ - "\u0005\u029d\u0000\u0000\u0827\u0828\u0005\u0319\u0000\u0000\u0828\u0829"+ - "\u0003\u0210\u0108\u0000\u0829\u082a\u0005\u02fa\u0000\u0000\u082a\u082b"+ - "\u0005\u029e\u0000\u0000\u082b\u082c\u0005\u0319\u0000\u0000\u082c\u0831"+ - "\u0003\u0210\u0108\u0000\u082d\u082e\u0005\u02fa\u0000\u0000\u082e\u082f"+ - "\u0005\u029f\u0000\u0000\u082f\u0830\u0005\u0319\u0000\u0000\u0830\u0832"+ - "\u0005\u0307\u0000\u0000\u0831\u082d\u0001\u0000\u0000\u0000\u0831\u0832"+ - "\u0001\u0000\u0000\u0000\u0832\u0837\u0001\u0000\u0000\u0000\u0833\u0834"+ - "\u0005\u02fa\u0000\u0000\u0834\u0835\u0005\u02a0\u0000\u0000\u0835\u0836"+ - "\u0005\u0319\u0000\u0000\u0836\u0838\u0003\u0210\u0108\u0000\u0837\u0833"+ - "\u0001\u0000\u0000\u0000\u0837\u0838\u0001\u0000\u0000\u0000\u0838\u083b"+ - "\u0001\u0000\u0000\u0000\u0839\u083a\u0005\u02fa\u0000\u0000\u083a\u083c"+ - "\u0005\u02a1\u0000\u0000\u083b\u0839\u0001\u0000\u0000\u0000\u083b\u083c"+ - "\u0001\u0000\u0000\u0000\u083c\u0841\u0001\u0000\u0000\u0000\u083d\u083e"+ - "\u0005\u02fa\u0000\u0000\u083e\u083f\u0005\u02a5\u0000\u0000\u083f\u0840"+ - "\u0005\u0319\u0000\u0000\u0840\u0842\u0003\u01b8\u00dc\u0000\u0841\u083d"+ - "\u0001\u0000\u0000\u0000\u0841\u0842\u0001\u0000\u0000\u0000\u0842\u0847"+ - "\u0001\u0000\u0000\u0000\u0843\u0844\u0005\u02fa\u0000\u0000\u0844\u0845"+ - "\u0005\u02ae\u0000\u0000\u0845\u0846\u0005\u0319\u0000\u0000\u0846\u0848"+ - "\u0007\u0007\u0000\u0000\u0847\u0843\u0001\u0000\u0000\u0000\u0847\u0848"+ - "\u0001\u0000\u0000\u0000\u0848\u084b\u0001\u0000\u0000\u0000\u0849\u084a"+ - "\u0005\u02fa\u0000\u0000\u084a\u084c\u0005\u02af\u0000\u0000\u084b\u0849"+ + "\u0308\u0003\u0308\u2906\b\u0308\u0001\u0308\u0001\u0308\u0001\u0308\u0001"+ + "\u0308\u0001\u0308\u0003\u0308\u290d\b\u0308\u0003\u0308\u290f\b\u0308"+ + "\u0001\u0308\u0001\u0308\u0001\u0309\u0001\u0309\u0001\u0309\u0001\u0309"+ + "\u0001\u0309\u0003\u0309\u2918\b\u0309\u0001\u030a\u0001\u030a\u0001\u030a"+ + "\u0005\u030a\u291d\b\u030a\n\u030a\f\u030a\u2920\t\u030a\u0001\u030b\u0001"+ + "\u030b\u0001\u030b\u0003\u030b\u2925\b\u030b\u0001\u030c\u0001\u030c\u0001"+ + "\u030c\u0001\u030c\u0003\u030c\u292b\b\u030c\u0001\u030d\u0001\u030d\u0003"+ + "\u030d\u292f\b\u030d\u0001\u030e\u0001\u030e\u0001\u030e\u0001\u030e\u0001"+ + "\u030e\u0001\u030e\u0001\u030e\u0001\u030e\u0001\u030f\u0001\u030f\u0001"+ + "\u0310\u0001\u0310\u0001\u0310\u0003\u0310\u293e\b\u0310\u0001\u0311\u0001"+ + "\u0311\u0001\u0311\u0001\u0311\u0001\u0311\u0001\u0311\u0001\u0311\u0001"+ + "\u0311\u0001\u0311\u0001\u0311\u0001\u0311\u0001\u0311\u0001\u0311\u0001"+ + "\u0311\u0001\u0311\u0003\u0311\u294f\b\u0311\u0003\u0311\u2951\b\u0311"+ + "\u0001\u0312\u0001\u0312\u0001\u0312\u0001\u0312\u0001\u0312\u0001\u0313"+ + "\u0001\u0313\u0001\u0313\u0001\u0313\u0001\u0314\u0001\u0314\u0001\u0314"+ + "\u0001\u0315\u0001\u0315\u0001\u0315\u0001\u0315\u0001\u0316\u0001\u0316"+ + "\u0001\u0316\u0001\u0316\u0001\u0317\u0001\u0317\u0003\u0317\u2969\b\u0317"+ + "\u0001\u0317\u0001\u0317\u0003\u0317\u296d\b\u0317\u0001\u0318\u0001\u0318"+ + "\u0001\u0318\u0001\u0318\u0001\u0318\u0001\u0318\u0001\u0318\u0001\u0318"+ + "\u0001\u0318\u0003\u0318\u2978\b\u0318\u0001\u0318\u0003\u0318\u297b\b"+ + "\u0318\u0001\u0319\u0001\u0319\u0003\u0319\u297f\b\u0319\u0001\u031a\u0001"+ + "\u031a\u0001\u031a\u0003\u031a\u2984\b\u031a\u0001\u031b\u0004\u031b\u2987"+ + "\b\u031b\u000b\u031b\f\u031b\u2988\u0001\u031c\u0001\u031c\u0001\u031c"+ + "\u0001\u031c\u0001\u031c\u0001\u031d\u0001\u031d\u0001\u031d\u0005\u031d"+ + "\u2993\b\u031d\n\u031d\f\u031d\u2996\t\u031d\u0001\u031e\u0001\u031e\u0001"+ + "\u031e\u0003\u031e\u299b\b\u031e\u0001\u031f\u0001\u031f\u0003\u031f\u299f"+ + "\b\u031f\u0001\u0320\u0001\u0320\u0003\u0320\u29a3\b\u0320\u0001\u0321"+ + "\u0001\u0321\u0003\u0321\u29a7\b\u0321\u0001\u0322\u0001\u0322\u0001\u0322"+ + "\u0003\u0322\u29ac\b\u0322\u0001\u0323\u0001\u0323\u0003\u0323\u29b0\b"+ + "\u0323\u0001\u0324\u0001\u0324\u0001\u0325\u0001\u0325\u0001\u0325\u0001"+ + "\u0325\u0001\u0325\u0001\u0325\u0001\u0325\u0001\u0325\u0001\u0326\u0001"+ + "\u0326\u0001\u0327\u0001\u0327\u0001\u0328\u0001\u0328\u0001\u0329\u0001"+ + "\u0329\u0001\u032a\u0001\u032a\u0001\u032a\u0001\u032b\u0001\u032b\u0001"+ + "\u032b\u0001\u032b\u0001\u032b\u0003\u032b\u29cc\b\u032b\u0001\u032c\u0001"+ + "\u032c\u0001\u032c\u0001\u032c\u0001\u032c\u0003\u032c\u29d3\b\u032c\u0001"+ + "\u032c\u0001\u032c\u0001\u032c\u0001\u032c\u0003\u032c\u29d9\b\u032c\u0001"+ + "\u032c\u0000\u0001\u04b6\u032d\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010"+ + "\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPR"+ + "TVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e"+ + "\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6"+ + "\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be"+ + "\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6"+ + "\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee"+ + "\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106"+ + "\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e"+ + "\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136"+ + "\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e"+ + "\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166"+ + "\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e"+ + "\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194\u0196"+ + "\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac\u01ae"+ + "\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0\u01c2\u01c4\u01c6"+ + "\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u01de"+ + "\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0\u01f2\u01f4\u01f6"+ + "\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e"+ + "\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226"+ + "\u0228\u022a\u022c\u022e\u0230\u0232\u0234\u0236\u0238\u023a\u023c\u023e"+ + "\u0240\u0242\u0244\u0246\u0248\u024a\u024c\u024e\u0250\u0252\u0254\u0256"+ + "\u0258\u025a\u025c\u025e\u0260\u0262\u0264\u0266\u0268\u026a\u026c\u026e"+ + "\u0270\u0272\u0274\u0276\u0278\u027a\u027c\u027e\u0280\u0282\u0284\u0286"+ + "\u0288\u028a\u028c\u028e\u0290\u0292\u0294\u0296\u0298\u029a\u029c\u029e"+ + "\u02a0\u02a2\u02a4\u02a6\u02a8\u02aa\u02ac\u02ae\u02b0\u02b2\u02b4\u02b6"+ + "\u02b8\u02ba\u02bc\u02be\u02c0\u02c2\u02c4\u02c6\u02c8\u02ca\u02cc\u02ce"+ + "\u02d0\u02d2\u02d4\u02d6\u02d8\u02da\u02dc\u02de\u02e0\u02e2\u02e4\u02e6"+ + "\u02e8\u02ea\u02ec\u02ee\u02f0\u02f2\u02f4\u02f6\u02f8\u02fa\u02fc\u02fe"+ + "\u0300\u0302\u0304\u0306\u0308\u030a\u030c\u030e\u0310\u0312\u0314\u0316"+ + "\u0318\u031a\u031c\u031e\u0320\u0322\u0324\u0326\u0328\u032a\u032c\u032e"+ + "\u0330\u0332\u0334\u0336\u0338\u033a\u033c\u033e\u0340\u0342\u0344\u0346"+ + "\u0348\u034a\u034c\u034e\u0350\u0352\u0354\u0356\u0358\u035a\u035c\u035e"+ + "\u0360\u0362\u0364\u0366\u0368\u036a\u036c\u036e\u0370\u0372\u0374\u0376"+ + "\u0378\u037a\u037c\u037e\u0380\u0382\u0384\u0386\u0388\u038a\u038c\u038e"+ + "\u0390\u0392\u0394\u0396\u0398\u039a\u039c\u039e\u03a0\u03a2\u03a4\u03a6"+ + "\u03a8\u03aa\u03ac\u03ae\u03b0\u03b2\u03b4\u03b6\u03b8\u03ba\u03bc\u03be"+ + "\u03c0\u03c2\u03c4\u03c6\u03c8\u03ca\u03cc\u03ce\u03d0\u03d2\u03d4\u03d6"+ + "\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee"+ + "\u03f0\u03f2\u03f4\u03f6\u03f8\u03fa\u03fc\u03fe\u0400\u0402\u0404\u0406"+ + "\u0408\u040a\u040c\u040e\u0410\u0412\u0414\u0416\u0418\u041a\u041c\u041e"+ + "\u0420\u0422\u0424\u0426\u0428\u042a\u042c\u042e\u0430\u0432\u0434\u0436"+ + "\u0438\u043a\u043c\u043e\u0440\u0442\u0444\u0446\u0448\u044a\u044c\u044e"+ + "\u0450\u0452\u0454\u0456\u0458\u045a\u045c\u045e\u0460\u0462\u0464\u0466"+ + "\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e"+ + "\u0480\u0482\u0484\u0486\u0488\u048a\u048c\u048e\u0490\u0492\u0494\u0496"+ + "\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae"+ + "\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0\u04c2\u04c4\u04c6"+ + "\u04c8\u04ca\u04cc\u04ce\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de"+ + "\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6"+ + "\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e"+ + "\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526"+ + "\u0528\u052a\u052c\u052e\u0530\u0532\u0534\u0536\u0538\u053a\u053c\u053e"+ + "\u0540\u0542\u0544\u0546\u0548\u054a\u054c\u054e\u0550\u0552\u0554\u0556"+ + "\u0558\u055a\u055c\u055e\u0560\u0562\u0564\u0566\u0568\u056a\u056c\u056e"+ + "\u0570\u0572\u0574\u0576\u0578\u057a\u057c\u057e\u0580\u0582\u0584\u0586"+ + "\u0588\u058a\u058c\u058e\u0590\u0592\u0594\u0596\u0598\u059a\u059c\u059e"+ + "\u05a0\u05a2\u05a4\u05a6\u05a8\u05aa\u05ac\u05ae\u05b0\u05b2\u05b4\u05b6"+ + "\u05b8\u05ba\u05bc\u05be\u05c0\u05c2\u05c4\u05c6\u05c8\u05ca\u05cc\u05ce"+ + "\u05d0\u05d2\u05d4\u05d6\u05d8\u05da\u05dc\u05de\u05e0\u05e2\u05e4\u05e6"+ + "\u05e8\u05ea\u05ec\u05ee\u05f0\u05f2\u05f4\u05f6\u05f8\u05fa\u05fc\u05fe"+ + "\u0600\u0602\u0604\u0606\u0608\u060a\u060c\u060e\u0610\u0612\u0614\u0616"+ + "\u0618\u061a\u061c\u061e\u0620\u0622\u0624\u0626\u0628\u062a\u062c\u062e"+ + "\u0630\u0632\u0634\u0636\u0638\u063a\u063c\u063e\u0640\u0642\u0644\u0646"+ + "\u0648\u064a\u064c\u064e\u0650\u0652\u0654\u0656\u0658\u0000E\u0002\u0000"+ + "\u00c5\u00c5\u0167\u0167\u0002\u0000DD\u0139\u0139\u0002\u0000ee\u0139"+ + "\u0139\u0003\u0000DDee\u0139\u0139\u0002\u0000\u0087\u0087\u00c1\u00c1"+ + "\u0002\u0000\u00f7\u00f7\u0147\u0147\u0002\u0000\f\f``\u0002\u0000\u00a4"+ + "\u00a4\u0166\u0166\u0002\u0000\u00b6\u00b6\u00df\u00df\u0005\u0000 \u011b"+ + "\u011b\u0144\u0144\u015b\u015b\u015d\u015d\u0002\u0000BB``\u0002\u0000"+ + "\u015b\u015b\u015d\u015d\u0002\u0000\u00ca\u00ca\u00e2\u00e2\t\u0000 "+ + " \u00a2\u00a2\u00a7\u00a7\u00b5\u00b5\u00dd\u00dd\u00e5\u00e5\u0151\u0151"+ + "\u0154\u0154\u01b8\u01b8\u0003\u0000ss\u0117\u0117\u014b\u014b\u0002\u0000"+ + "77PP\u0003\u0000\u00af\u00af\u00fe\u00fe\u0101\u0101\u0005\u0000 ZZ\u00b8"+ + "\u00b8\u00ea\u00ea\u016c\u016c\u0002\u0000^^\u00e4\u00e4\u0001\u0000\u01c2"+ + "\u01c3\u0002\u0000^^\u0199\u0199\u0002\u0000\u0150\u0150\u0199\u0199\u0002"+ + "\u0000\u00d5\u00d5\u0123\u0123\u0003\u0000\u013c\u013c\u0160\u0160\u01bf"+ + "\u01bf\u0002\u0000BBFF\u0005\u0000\u00d6\u00d6\u0144\u0144\u0159\u0159"+ + "\u0164\u0164\u01c9\u01ca\u0002\u0000\f\f77\u0003\u0000\u00d5\u00d5\u0123"+ + "\u0123\u01bc\u01bc\u0005\u0000^^\u00b1\u00b1\u00e4\u00e4\u013e\u013e\u0158"+ + "\u0158\u0003\u0000\u00b1\u00b1\u013e\u013e\u0158\u0158\u0003\u0000oo\u0082"+ + "\u0082\u015a\u015a\u0004\u0000ZZ\u00b8\u00b8\u00ea\u00ea\u016c\u016c\u0002"+ + "\u0000\u0099\u0099\u00f7\u00f7\u0002\u0000\u0134\u0134\u0148\u0148\u0001"+ + "\u0000!\"\u0002\u0000ee\u0158\u0158\u0002\u0000\u00cb\u00cb\u0149\u0149"+ + "\u0002\u0000==cc\u0002\u0000\u00d7\u00d7\u00f7\u00f7\u0002\u0000\u013b"+ + "\u013b\u0199\u0199\u0002\u0000\u00d1\u00d1\u0107\u0107\u0004\u0000ssu"+ + "uyy\u0080\u0080\u0002\u0000\u0163\u0163\u01df\u01df\u0002\u0000\u0182"+ + "\u0183\u0191\u0191\u0001\u0000\u0182\u0183\u0001\u0000\u019d\u019e\u0001"+ + "\u0000\u0014\u0015\u0002\u0000ww||\u0005\u0000\f\f\u0012\u0013\u0017\u0017"+ + "\u0019\u0019\u001b\u001b\u0001\u0000\u000e\u000f\u0003\u0000\u000b\u000b"+ + "\u0010\u0010\u001d\u001d\u0002\u0000 ::\u0003\u0000))KKaa\u0002\u0000"+ + "\u00a8\u00a8\u00be\u00be\u0002\u0000\u012b\u012b\u01c4\u01c4\u0002\u0000"+ + "\u00d2\u00d2\u011c\u011c\u0003\u0000 $$\\\\\u0006\u0000\u000b\f\u000e"+ + "\u0013\u0017\u0017\u0019\u0019\u001b\u001b\u001d\u001d\u0002\u0000\u0016"+ + "\u0016\u0018\u0018\u0001\u0000\u01e5\u01e8\u000b\u0000~~\u0083\u00fb\u00fd"+ + "\u00fe\u0100\u0131\u0133\u017d\u01b3\u01c6\u01c9\u01d7\u01d9\u01d9\u01db"+ + "\u01db\u01dd\u01dd\u01e0\u01ea\u0005\u0000lxz}\u007f\u007f\u0081\u0082"+ + "\u01da\u01da\u0004\u0000 68HJk\u01c8\u01c8\u0005\u0000\u0132\u0132\u01a4"+ + "\u01aa\u01fa\u01fa\u0203\u0203\u020c\u027e\u0002\u0000@@vv\u0002\u0000"+ + "\f\f\u0016\u0016\u0002\u0000\u00a9\u00a9\u01fd\u01fd\u0002\u0000\u0092"+ + "\u0092\u00d4\u00d4$\u0000##%%-/77;;??^^vv}}\u0084\u0084\u0092\u0092\u009b"+ + "\u009b\u009f\u009f\u00a3\u00a3\u00a9\u00a9\u00ae\u00ae\u00d1\u00d1\u00d4"+ + "\u00d4\u00ea\u00ea\u00f2\u00f2\u0104\u0104\u0107\u0108\u0112\u0112\u0120"+ + "\u0120\u012e\u012e\u0134\u0134\u013a\u013a\u013e\u013f\u0148\u0148\u0163"+ + "\u0163\u01b3\u01b4\u01df\u01df\u01ec\u01f8\u01fc\u0202\u0204\u0208\u020a"+ + "\u020a\u2d3c\u0000\u065a\u0001\u0000\u0000\u0000\u0002\u065d\u0001\u0000"+ + "\u0000\u0000\u0004\u065f\u0001\u0000\u0000\u0000\u0006\u0667\u0001\u0000"+ + "\u0000\u0000\b\u06e7\u0001\u0000\u0000\u0000\n\u06e9\u0001\u0000\u0000"+ + "\u0000\f\u06ed\u0001\u0000\u0000\u0000\u000e\u06f0\u0001\u0000\u0000\u0000"+ + "\u0010\u06f8\u0001\u0000\u0000\u0000\u0012\u06fd\u0001\u0000\u0000\u0000"+ + "\u0014\u0703\u0001\u0000\u0000\u0000\u0016\u0718\u0001\u0000\u0000\u0000"+ + "\u0018\u0724\u0001\u0000\u0000\u0000\u001a\u0726\u0001\u0000\u0000\u0000"+ + "\u001c\u072c\u0001\u0000\u0000\u0000\u001e\u0736\u0001\u0000\u0000\u0000"+ + " \u0738\u0001\u0000\u0000\u0000\"\u0741\u0001\u0000\u0000\u0000$\u0749"+ + "\u0001\u0000\u0000\u0000&\u074f\u0001\u0000\u0000\u0000(\u0756\u0001\u0000"+ + "\u0000\u0000*\u0758\u0001\u0000\u0000\u0000,\u076a\u0001\u0000\u0000\u0000"+ + ".\u076f\u0001\u0000\u0000\u00000\u0778\u0001\u0000\u0000\u00002\u077a"+ + "\u0001\u0000\u0000\u00004\u0788\u0001\u0000\u0000\u00006\u078a\u0001\u0000"+ + "\u0000\u00008\u07a7\u0001\u0000\u0000\u0000:\u07a9\u0001\u0000\u0000\u0000"+ + "<\u07b1\u0001\u0000\u0000\u0000>\u07bb\u0001\u0000\u0000\u0000@\u07c2"+ + "\u0001\u0000\u0000\u0000B\u07c8\u0001\u0000\u0000\u0000D\u07d9\u0001\u0000"+ + "\u0000\u0000F\u07de\u0001\u0000\u0000\u0000H\u07e2\u0001\u0000\u0000\u0000"+ + "J\u07e4\u0001\u0000\u0000\u0000L\u07ef\u0001\u0000\u0000\u0000N\u07f3"+ + "\u0001\u0000\u0000\u0000P\u07f8\u0001\u0000\u0000\u0000R\u07fd\u0001\u0000"+ + "\u0000\u0000T\u07ff\u0001\u0000\u0000\u0000V\u080b\u0001\u0000\u0000\u0000"+ + "X\u0812\u0001\u0000\u0000\u0000Z\u0814\u0001\u0000\u0000\u0000\\\u0816"+ + "\u0001\u0000\u0000\u0000^\u0818\u0001\u0000\u0000\u0000`\u0888\u0001\u0000"+ + "\u0000\u0000b\u088a\u0001\u0000\u0000\u0000d\u089a\u0001\u0000\u0000\u0000"+ + "f\u089c\u0001\u0000\u0000\u0000h\u099c\u0001\u0000\u0000\u0000j\u09a3"+ + "\u0001\u0000\u0000\u0000l\u09a8\u0001\u0000\u0000\u0000n\u09ad\u0001\u0000"+ + "\u0000\u0000p\u09b2\u0001\u0000\u0000\u0000r\u09ba\u0001\u0000\u0000\u0000"+ + "t\u09bc\u0001\u0000\u0000\u0000v\u09c3\u0001\u0000\u0000\u0000x\u09c5"+ + "\u0001\u0000\u0000\u0000z\u09cd\u0001\u0000\u0000\u0000|\u09d9\u0001\u0000"+ + "\u0000\u0000~\u09e9\u0001\u0000\u0000\u0000\u0080\u0a05\u0001\u0000\u0000"+ + "\u0000\u0082\u0a07\u0001\u0000\u0000\u0000\u0084\u0a0a\u0001\u0000\u0000"+ + "\u0000\u0086\u0a12\u0001\u0000\u0000\u0000\u0088\u0a17\u0001\u0000\u0000"+ + "\u0000\u008a\u0a36\u0001\u0000\u0000\u0000\u008c\u0a38\u0001\u0000\u0000"+ + "\u0000\u008e\u0a53\u0001\u0000\u0000\u0000\u0090\u0a55\u0001\u0000\u0000"+ + "\u0000\u0092\u0a59\u0001\u0000\u0000\u0000\u0094\u0a5e\u0001\u0000\u0000"+ + "\u0000\u0096\u0a65\u0001\u0000\u0000\u0000\u0098\u0a6a\u0001\u0000\u0000"+ + "\u0000\u009a\u0a90\u0001\u0000\u0000\u0000\u009c\u0a94\u0001\u0000\u0000"+ + "\u0000\u009e\u0a9b\u0001\u0000\u0000\u0000\u00a0\u0a9f\u0001\u0000\u0000"+ + "\u0000\u00a2\u0aa1\u0001\u0000\u0000\u0000\u00a4\u0aa9\u0001\u0000\u0000"+ + "\u0000\u00a6\u0ab4\u0001\u0000\u0000\u0000\u00a8\u0ab6\u0001\u0000\u0000"+ + "\u0000\u00aa\u0abe\u0001\u0000\u0000\u0000\u00ac\u0ac0\u0001\u0000\u0000"+ + "\u0000\u00ae\u0af1\u0001\u0000\u0000\u0000\u00b0\u0af5\u0001\u0000\u0000"+ + "\u0000\u00b2\u0afc\u0001\u0000\u0000\u0000\u00b4\u0afe\u0001\u0000\u0000"+ + "\u0000\u00b6\u0b06\u0001\u0000\u0000\u0000\u00b8\u0b11\u0001\u0000\u0000"+ + "\u0000\u00ba\u0b15\u0001\u0000\u0000\u0000\u00bc\u0b17\u0001\u0000\u0000"+ + "\u0000\u00be\u0b1c\u0001\u0000\u0000\u0000\u00c0\u0b26\u0001\u0000\u0000"+ + "\u0000\u00c2\u0b31\u0001\u0000\u0000\u0000\u00c4\u0b59\u0001\u0000\u0000"+ + "\u0000\u00c6\u0b5e\u0001\u0000\u0000\u0000\u00c8\u0b65\u0001\u0000\u0000"+ + "\u0000\u00ca\u0b67\u0001\u0000\u0000\u0000\u00cc\u0b6f\u0001\u0000\u0000"+ + "\u0000\u00ce\u0b72\u0001\u0000\u0000\u0000\u00d0\u0b79\u0001\u0000\u0000"+ + "\u0000\u00d2\u0bb5\u0001\u0000\u0000\u0000\u00d4\u0bba\u0001\u0000\u0000"+ + "\u0000\u00d6\u0bc1\u0001\u0000\u0000\u0000\u00d8\u0bc3\u0001\u0000\u0000"+ + "\u0000\u00da\u0bcb\u0001\u0000\u0000\u0000\u00dc\u0bd3\u0001\u0000\u0000"+ + "\u0000\u00de\u0bd8\u0001\u0000\u0000\u0000\u00e0\u0bda\u0001\u0000\u0000"+ + "\u0000\u00e2\u0be2\u0001\u0000\u0000\u0000\u00e4\u0bf2\u0001\u0000\u0000"+ + "\u0000\u00e6\u0bfd\u0001\u0000\u0000\u0000\u00e8\u0bff\u0001\u0000\u0000"+ + "\u0000\u00ea\u0c03\u0001\u0000\u0000\u0000\u00ec\u0c0d\u0001\u0000\u0000"+ + "\u0000\u00ee\u0c15\u0001\u0000\u0000\u0000\u00f0\u0c19\u0001\u0000\u0000"+ + "\u0000\u00f2\u0c1b\u0001\u0000\u0000\u0000\u00f4\u0c22\u0001\u0000\u0000"+ + "\u0000\u00f6\u0c38\u0001\u0000\u0000\u0000\u00f8\u0c3d\u0001\u0000\u0000"+ + "\u0000\u00fa\u0c44\u0001\u0000\u0000\u0000\u00fc\u0c50\u0001\u0000\u0000"+ + "\u0000\u00fe\u0c55\u0001\u0000\u0000\u0000\u0100\u0c5c\u0001\u0000\u0000"+ + "\u0000\u0102\u0c5e\u0001\u0000\u0000\u0000\u0104\u0c62\u0001\u0000\u0000"+ + "\u0000\u0106\u0c70\u0001\u0000\u0000\u0000\u0108\u0c7b\u0001\u0000\u0000"+ + "\u0000\u010a\u0c88\u0001\u0000\u0000\u0000\u010c\u0c96\u0001\u0000\u0000"+ + "\u0000\u010e\u0c98\u0001\u0000\u0000\u0000\u0110\u0ca6\u0001\u0000\u0000"+ + "\u0000\u0112\u0cae\u0001\u0000\u0000\u0000\u0114\u0cb0\u0001\u0000\u0000"+ + "\u0000\u0116\u0cb7\u0001\u0000\u0000\u0000\u0118\u0cc2\u0001\u0000\u0000"+ + "\u0000\u011a\u0ccd\u0001\u0000\u0000\u0000\u011c\u0cd4\u0001\u0000\u0000"+ + "\u0000\u011e\u0cd7\u0001\u0000\u0000\u0000\u0120\u0cf9\u0001\u0000\u0000"+ + "\u0000\u0122\u0cfd\u0001\u0000\u0000\u0000\u0124\u0d05\u0001\u0000\u0000"+ + "\u0000\u0126\u0d07\u0001\u0000\u0000\u0000\u0128\u0d0f\u0001\u0000\u0000"+ + "\u0000\u012a\u0d1e\u0001\u0000\u0000\u0000\u012c\u0d20\u0001\u0000\u0000"+ + "\u0000\u012e\u0d27\u0001\u0000\u0000\u0000\u0130\u0d2d\u0001\u0000\u0000"+ + "\u0000\u0132\u0d31\u0001\u0000\u0000\u0000\u0134\u0d35\u0001\u0000\u0000"+ + "\u0000\u0136\u0d37\u0001\u0000\u0000\u0000\u0138\u0d42\u0001\u0000\u0000"+ + "\u0000\u013a\u0d44\u0001\u0000\u0000\u0000\u013c\u0d4c\u0001\u0000\u0000"+ + "\u0000\u013e\u0d5a\u0001\u0000\u0000\u0000\u0140\u0d64\u0001\u0000\u0000"+ + "\u0000\u0142\u0d66\u0001\u0000\u0000\u0000\u0144\u0d6f\u0001\u0000\u0000"+ + "\u0000\u0146\u0d72\u0001\u0000\u0000\u0000\u0148\u0ddd\u0001\u0000\u0000"+ + "\u0000\u014a\u0ddf\u0001\u0000\u0000\u0000\u014c\u0def\u0001\u0000\u0000"+ + "\u0000\u014e\u0df2\u0001\u0000\u0000\u0000\u0150\u0df8\u0001\u0000\u0000"+ + "\u0000\u0152\u0e09\u0001\u0000\u0000\u0000\u0154\u0e11\u0001\u0000\u0000"+ + "\u0000\u0156\u0e13\u0001\u0000\u0000\u0000\u0158\u0e1b\u0001\u0000\u0000"+ + "\u0000\u015a\u0e20\u0001\u0000\u0000\u0000\u015c\u0e2f\u0001\u0000\u0000"+ + "\u0000\u015e\u0e31\u0001\u0000\u0000\u0000\u0160\u0e34\u0001\u0000\u0000"+ + "\u0000\u0162\u0e36\u0001\u0000\u0000\u0000\u0164\u0e51\u0001\u0000\u0000"+ + "\u0000\u0166\u0e56\u0001\u0000\u0000\u0000\u0168\u0e58\u0001\u0000\u0000"+ + "\u0000\u016a\u0e5f\u0001\u0000\u0000\u0000\u016c\u0e61\u0001\u0000\u0000"+ + "\u0000\u016e\u0ea3\u0001\u0000\u0000\u0000\u0170\u0ea5\u0001\u0000\u0000"+ + "\u0000\u0172\u0eb4\u0001\u0000\u0000\u0000\u0174\u0ebc\u0001\u0000\u0000"+ + "\u0000\u0176\u0ed3\u0001\u0000\u0000\u0000\u0178\u0ed7\u0001\u0000\u0000"+ + "\u0000\u017a\u0eeb\u0001\u0000\u0000\u0000\u017c\u0eed\u0001\u0000\u0000"+ + "\u0000\u017e\u0ef6\u0001\u0000\u0000\u0000\u0180\u0f01\u0001\u0000\u0000"+ + "\u0000\u0182\u0f10\u0001\u0000\u0000\u0000\u0184\u0f19\u0001\u0000\u0000"+ + "\u0000\u0186\u0f1e\u0001\u0000\u0000\u0000\u0188\u0f23\u0001\u0000\u0000"+ + "\u0000\u018a\u0f28\u0001\u0000\u0000\u0000\u018c\u0f2d\u0001\u0000\u0000"+ + "\u0000\u018e\u0f2f\u0001\u0000\u0000\u0000\u0190\u0f31\u0001\u0000\u0000"+ + "\u0000\u0192\u0f3a\u0001\u0000\u0000\u0000\u0194\u0f62\u0001\u0000\u0000"+ + "\u0000\u0196\u0f68\u0001\u0000\u0000\u0000\u0198\u0f6a\u0001\u0000\u0000"+ + "\u0000\u019a\u0f79\u0001\u0000\u0000\u0000\u019c\u0f7e\u0001\u0000\u0000"+ + "\u0000\u019e\u0f81\u0001\u0000\u0000\u0000\u01a0\u0f85\u0001\u0000\u0000"+ + "\u0000\u01a2\u0f8a\u0001\u0000\u0000\u0000\u01a4\u0f8c\u0001\u0000\u0000"+ + "\u0000\u01a6\u0f8e\u0001\u0000\u0000\u0000\u01a8\u0f95\u0001\u0000\u0000"+ + "\u0000\u01aa\u0f99\u0001\u0000\u0000\u0000\u01ac\u0f9b\u0001\u0000\u0000"+ + "\u0000\u01ae\u0fa3\u0001\u0000\u0000\u0000\u01b0\u0fa5\u0001\u0000\u0000"+ + "\u0000\u01b2\u0fa9\u0001\u0000\u0000\u0000\u01b4\u0fb6\u0001\u0000\u0000"+ + "\u0000\u01b6\u0fbb\u0001\u0000\u0000\u0000\u01b8\u0fc0\u0001\u0000\u0000"+ + "\u0000\u01ba\u0fce\u0001\u0000\u0000\u0000\u01bc\u0fea\u0001\u0000\u0000"+ + "\u0000\u01be\u0fec\u0001\u0000\u0000\u0000\u01c0\u0ff4\u0001\u0000\u0000"+ + "\u0000\u01c2\u0ffa\u0001\u0000\u0000\u0000\u01c4\u1002\u0001\u0000\u0000"+ + "\u0000\u01c6\u100e\u0001\u0000\u0000\u0000\u01c8\u1010\u0001\u0000\u0000"+ + "\u0000\u01ca\u1083\u0001\u0000\u0000\u0000\u01cc\u1085\u0001\u0000\u0000"+ + "\u0000\u01ce\u1089\u0001\u0000\u0000\u0000\u01d0\u1091\u0001\u0000\u0000"+ + "\u0000\u01d2\u109c\u0001\u0000\u0000\u0000\u01d4\u109e\u0001\u0000\u0000"+ + "\u0000\u01d6\u10a2\u0001\u0000\u0000\u0000\u01d8\u10aa\u0001\u0000\u0000"+ + "\u0000\u01da\u10b0\u0001\u0000\u0000\u0000\u01dc\u10b2\u0001\u0000\u0000"+ + "\u0000\u01de\u10df\u0001\u0000\u0000\u0000\u01e0\u10e5\u0001\u0000\u0000"+ + "\u0000\u01e2\u10e7\u0001\u0000\u0000\u0000\u01e4\u10f5\u0001\u0000\u0000"+ + "\u0000\u01e6\u1116\u0001\u0000\u0000\u0000\u01e8\u111a\u0001\u0000\u0000"+ + "\u0000\u01ea\u111f\u0001\u0000\u0000\u0000\u01ec\u1128\u0001\u0000\u0000"+ + "\u0000\u01ee\u112c\u0001\u0000\u0000\u0000\u01f0\u112e\u0001\u0000\u0000"+ + "\u0000\u01f2\u1147\u0001\u0000\u0000\u0000\u01f4\u1149\u0001\u0000\u0000"+ + "\u0000\u01f6\u115d\u0001\u0000\u0000\u0000\u01f8\u1171\u0001\u0000\u0000"+ + "\u0000\u01fa\u1185\u0001\u0000\u0000\u0000\u01fc\u1187\u0001\u0000\u0000"+ + "\u0000\u01fe\u118d\u0001\u0000\u0000\u0000\u0200\u11e2\u0001\u0000\u0000"+ + "\u0000\u0202\u11fb\u0001\u0000\u0000\u0000\u0204\u1202\u0001\u0000\u0000"+ + "\u0000\u0206\u1212\u0001\u0000\u0000\u0000\u0208\u1214\u0001\u0000\u0000"+ + "\u0000\u020a\u1216\u0001\u0000\u0000\u0000\u020c\u121e\u0001\u0000\u0000"+ + "\u0000\u020e\u1224\u0001\u0000\u0000\u0000\u0210\u1228\u0001\u0000\u0000"+ + "\u0000\u0212\u1230\u0001\u0000\u0000\u0000\u0214\u123b\u0001\u0000\u0000"+ + "\u0000\u0216\u12d0\u0001\u0000\u0000\u0000\u0218\u12d4\u0001\u0000\u0000"+ + "\u0000\u021a\u1331\u0001\u0000\u0000\u0000\u021c\u1336\u0001\u0000\u0000"+ + "\u0000\u021e\u133a\u0001\u0000\u0000\u0000\u0220\u1340\u0001\u0000\u0000"+ + "\u0000\u0222\u1384\u0001\u0000\u0000\u0000\u0224\u1386\u0001\u0000\u0000"+ + "\u0000\u0226\u138a\u0001\u0000\u0000\u0000\u0228\u138c\u0001\u0000\u0000"+ + "\u0000\u022a\u13a7\u0001\u0000\u0000\u0000\u022c\u13b8\u0001\u0000\u0000"+ + "\u0000\u022e\u13ba\u0001\u0000\u0000\u0000\u0230\u13cb\u0001\u0000\u0000"+ + "\u0000\u0232\u1407\u0001\u0000\u0000\u0000\u0234\u1409\u0001\u0000\u0000"+ + "\u0000\u0236\u1414\u0001\u0000\u0000\u0000\u0238\u141a\u0001\u0000\u0000"+ + "\u0000\u023a\u141c\u0001\u0000\u0000\u0000\u023c\u1434\u0001\u0000\u0000"+ + "\u0000\u023e\u143a\u0001\u0000\u0000\u0000\u0240\u1440\u0001\u0000\u0000"+ + "\u0000\u0242\u1442\u0001\u0000\u0000\u0000\u0244\u144b\u0001\u0000\u0000"+ + "\u0000\u0246\u1457\u0001\u0000\u0000\u0000\u0248\u1474\u0001\u0000\u0000"+ + "\u0000\u024a\u1476\u0001\u0000\u0000\u0000\u024c\u149b\u0001\u0000\u0000"+ + "\u0000\u024e\u149f\u0001\u0000\u0000\u0000\u0250\u14a3\u0001\u0000\u0000"+ + "\u0000\u0252\u14a7\u0001\u0000\u0000\u0000\u0254\u14ac\u0001\u0000\u0000"+ + "\u0000\u0256\u14ae\u0001\u0000\u0000\u0000\u0258\u14c1\u0001\u0000\u0000"+ + "\u0000\u025a\u14ce\u0001\u0000\u0000\u0000\u025c\u14d6\u0001\u0000\u0000"+ + "\u0000\u025e\u14d8\u0001\u0000\u0000\u0000\u0260\u14e3\u0001\u0000\u0000"+ + "\u0000\u0262\u14e7\u0001\u0000\u0000\u0000\u0264\u14ec\u0001\u0000\u0000"+ + "\u0000\u0266\u14f3\u0001\u0000\u0000\u0000\u0268\u14f5\u0001\u0000\u0000"+ + "\u0000\u026a\u150a\u0001\u0000\u0000\u0000\u026c\u150c\u0001\u0000\u0000"+ + "\u0000\u026e\u1512\u0001\u0000\u0000\u0000\u0270\u151a\u0001\u0000\u0000"+ + "\u0000\u0272\u152a\u0001\u0000\u0000\u0000\u0274\u152c\u0001\u0000\u0000"+ + "\u0000\u0276\u1532\u0001\u0000\u0000\u0000\u0278\u1547\u0001\u0000\u0000"+ + "\u0000\u027a\u1550\u0001\u0000\u0000\u0000\u027c\u1556\u0001\u0000\u0000"+ + "\u0000\u027e\u1558\u0001\u0000\u0000\u0000\u0280\u1568\u0001\u0000\u0000"+ + "\u0000\u0282\u156a\u0001\u0000\u0000\u0000\u0284\u156f\u0001\u0000\u0000"+ + "\u0000\u0286\u1571\u0001\u0000\u0000\u0000\u0288\u1580\u0001\u0000\u0000"+ + "\u0000\u028a\u1588\u0001\u0000\u0000\u0000\u028c\u158b\u0001\u0000\u0000"+ + "\u0000\u028e\u1594\u0001\u0000\u0000\u0000\u0290\u15bd\u0001\u0000\u0000"+ + "\u0000\u0292\u15c7\u0001\u0000\u0000\u0000\u0294\u15ce\u0001\u0000\u0000"+ + "\u0000\u0296\u15d0\u0001\u0000\u0000\u0000\u0298\u15df\u0001\u0000\u0000"+ + "\u0000\u029a\u15e1\u0001\u0000\u0000\u0000\u029c\u15e4\u0001\u0000\u0000"+ + "\u0000\u029e\u15ec\u0001\u0000\u0000\u0000\u02a0\u15f3\u0001\u0000\u0000"+ + "\u0000\u02a2\u15f9\u0001\u0000\u0000\u0000\u02a4\u161f\u0001\u0000\u0000"+ + "\u0000\u02a6\u162d\u0001\u0000\u0000\u0000\u02a8\u163b\u0001\u0000\u0000"+ + "\u0000\u02aa\u1653\u0001\u0000\u0000\u0000\u02ac\u165a\u0001\u0000\u0000"+ + "\u0000\u02ae\u165f\u0001\u0000\u0000\u0000\u02b0\u1667\u0001\u0000\u0000"+ + "\u0000\u02b2\u166a\u0001\u0000\u0000\u0000\u02b4\u166e\u0001\u0000\u0000"+ + "\u0000\u02b6\u1675\u0001\u0000\u0000\u0000\u02b8\u1699\u0001\u0000\u0000"+ + "\u0000\u02ba\u16a0\u0001\u0000\u0000\u0000\u02bc\u16a2\u0001\u0000\u0000"+ + "\u0000\u02be\u16af\u0001\u0000\u0000\u0000\u02c0\u16b1\u0001\u0000\u0000"+ + "\u0000\u02c2\u16de\u0001\u0000\u0000\u0000\u02c4\u16e0\u0001\u0000\u0000"+ + "\u0000\u02c6\u1703\u0001\u0000\u0000\u0000\u02c8\u1705\u0001\u0000\u0000"+ + "\u0000\u02ca\u1707\u0001\u0000\u0000\u0000\u02cc\u1709\u0001\u0000\u0000"+ + "\u0000\u02ce\u1711\u0001\u0000\u0000\u0000\u02d0\u171f\u0001\u0000\u0000"+ + "\u0000\u02d2\u18f5\u0001\u0000\u0000\u0000\u02d4\u18f9\u0001\u0000\u0000"+ + "\u0000\u02d6\u18fe\u0001\u0000\u0000\u0000\u02d8\u1939\u0001\u0000\u0000"+ + "\u0000\u02da\u193d\u0001\u0000\u0000\u0000\u02dc\u1a18\u0001\u0000\u0000"+ + "\u0000\u02de\u1a1a\u0001\u0000\u0000\u0000\u02e0\u1a22\u0001\u0000\u0000"+ + "\u0000\u02e2\u1a32\u0001\u0000\u0000\u0000\u02e4\u1a39\u0001\u0000\u0000"+ + "\u0000\u02e6\u1a3b\u0001\u0000\u0000\u0000\u02e8\u1afa\u0001\u0000\u0000"+ + "\u0000\u02ea\u1afc\u0001\u0000\u0000\u0000\u02ec\u1b04\u0001\u0000\u0000"+ + "\u0000\u02ee\u1b0c\u0001\u0000\u0000\u0000\u02f0\u1b29\u0001\u0000\u0000"+ + "\u0000\u02f2\u1b2b\u0001\u0000\u0000\u0000\u02f4\u1b34\u0001\u0000\u0000"+ + "\u0000\u02f6\u1b3c\u0001\u0000\u0000\u0000\u02f8\u1b63\u0001\u0000\u0000"+ + "\u0000\u02fa\u1b71\u0001\u0000\u0000\u0000\u02fc\u1b73\u0001\u0000\u0000"+ + "\u0000\u02fe\u1b87\u0001\u0000\u0000\u0000\u0300\u1b89\u0001\u0000\u0000"+ + "\u0000\u0302\u1b96\u0001\u0000\u0000\u0000\u0304\u1b9a\u0001\u0000\u0000"+ + "\u0000\u0306\u1b9c\u0001\u0000\u0000\u0000\u0308\u1ba1\u0001\u0000\u0000"+ + "\u0000\u030a\u1ba3\u0001\u0000\u0000\u0000\u030c\u1baa\u0001\u0000\u0000"+ + "\u0000\u030e\u1bac\u0001\u0000\u0000\u0000\u0310\u1bb3\u0001\u0000\u0000"+ + "\u0000\u0312\u1be7\u0001\u0000\u0000\u0000\u0314\u1bec\u0001\u0000\u0000"+ + "\u0000\u0316\u1bf8\u0001\u0000\u0000\u0000\u0318\u1bfa\u0001\u0000\u0000"+ + "\u0000\u031a\u1c06\u0001\u0000\u0000\u0000\u031c\u1c0e\u0001\u0000\u0000"+ + "\u0000\u031e\u1c10\u0001\u0000\u0000\u0000\u0320\u1c30\u0001\u0000\u0000"+ + "\u0000\u0322\u1c32\u0001\u0000\u0000\u0000\u0324\u1c35\u0001\u0000\u0000"+ + "\u0000\u0326\u1c3d\u0001\u0000\u0000\u0000\u0328\u1c40\u0001\u0000\u0000"+ + "\u0000\u032a\u1c44\u0001\u0000\u0000\u0000\u032c\u1c53\u0001\u0000\u0000"+ + "\u0000\u032e\u1c57\u0001\u0000\u0000\u0000\u0330\u1c59\u0001\u0000\u0000"+ + "\u0000\u0332\u1c64\u0001\u0000\u0000\u0000\u0334\u1c69\u0001\u0000\u0000"+ + "\u0000\u0336\u1c77\u0001\u0000\u0000\u0000\u0338\u1c7f\u0001\u0000\u0000"+ + "\u0000\u033a\u1c81\u0001\u0000\u0000\u0000\u033c\u1c87\u0001\u0000\u0000"+ + "\u0000\u033e\u1c8c\u0001\u0000\u0000\u0000\u0340\u1c93\u0001\u0000\u0000"+ + "\u0000\u0342\u1caf\u0001\u0000\u0000\u0000\u0344\u1cb1\u0001\u0000\u0000"+ + "\u0000\u0346\u1d00\u0001\u0000\u0000\u0000\u0348\u1d02\u0001\u0000\u0000"+ + "\u0000\u034a\u1d04\u0001\u0000\u0000\u0000\u034c\u1d1c\u0001\u0000\u0000"+ + "\u0000\u034e\u1d21\u0001\u0000\u0000\u0000\u0350\u1d30\u0001\u0000\u0000"+ + "\u0000\u0352\u1d3c\u0001\u0000\u0000\u0000\u0354\u1d3e\u0001\u0000\u0000"+ + "\u0000\u0356\u1d46\u0001\u0000\u0000\u0000\u0358\u1d48\u0001\u0000\u0000"+ + "\u0000\u035a\u1d4d\u0001\u0000\u0000\u0000\u035c\u1d52\u0001\u0000\u0000"+ + "\u0000\u035e\u1d56\u0001\u0000\u0000\u0000\u0360\u1d5a\u0001\u0000\u0000"+ + "\u0000\u0362\u1d5e\u0001\u0000\u0000\u0000\u0364\u1d62\u0001\u0000\u0000"+ + "\u0000\u0366\u1d69\u0001\u0000\u0000\u0000\u0368\u1d6b\u0001\u0000\u0000"+ + "\u0000\u036a\u1d6e\u0001\u0000\u0000\u0000\u036c\u1d78\u0001\u0000\u0000"+ + "\u0000\u036e\u1d8a\u0001\u0000\u0000\u0000\u0370\u1d95\u0001\u0000\u0000"+ + "\u0000\u0372\u1d97\u0001\u0000\u0000\u0000\u0374\u1d9f\u0001\u0000\u0000"+ + "\u0000\u0376\u1da4\u0001\u0000\u0000\u0000\u0378\u1da9\u0001\u0000\u0000"+ + "\u0000\u037a\u1dab\u0001\u0000\u0000\u0000\u037c\u1db6\u0001\u0000\u0000"+ + "\u0000\u037e\u1dbc\u0001\u0000\u0000\u0000\u0380\u1dd9\u0001\u0000\u0000"+ + "\u0000\u0382\u1de0\u0001\u0000\u0000\u0000\u0384\u1dec\u0001\u0000\u0000"+ + "\u0000\u0386\u1dee\u0001\u0000\u0000\u0000\u0388\u1df6\u0001\u0000\u0000"+ + "\u0000\u038a\u1e0e\u0001\u0000\u0000\u0000\u038c\u1e10\u0001\u0000\u0000"+ + "\u0000\u038e\u1e12\u0001\u0000\u0000\u0000\u0390\u1e1a\u0001\u0000\u0000"+ + "\u0000\u0392\u1e2a\u0001\u0000\u0000\u0000\u0394\u1e35\u0001\u0000\u0000"+ + "\u0000\u0396\u1e3a\u0001\u0000\u0000\u0000\u0398\u1e3c\u0001\u0000\u0000"+ + "\u0000\u039a\u1e5b\u0001\u0000\u0000\u0000\u039c\u1e6e\u0001\u0000\u0000"+ + "\u0000\u039e\u1e7b\u0001\u0000\u0000\u0000\u03a0\u1e82\u0001\u0000\u0000"+ + "\u0000\u03a2\u1e8d\u0001\u0000\u0000\u0000\u03a4\u1e8f\u0001\u0000\u0000"+ + "\u0000\u03a6\u1e9a\u0001\u0000\u0000\u0000\u03a8\u1ea8\u0001\u0000\u0000"+ + "\u0000\u03aa\u1eac\u0001\u0000\u0000\u0000\u03ac\u1eb2\u0001\u0000\u0000"+ + "\u0000\u03ae\u1eb4\u0001\u0000\u0000\u0000\u03b0\u1ebd\u0001\u0000\u0000"+ + "\u0000\u03b2\u1ecf\u0001\u0000\u0000\u0000\u03b4\u1ed1\u0001\u0000\u0000"+ + "\u0000\u03b6\u1ed4\u0001\u0000\u0000\u0000\u03b8\u1edc\u0001\u0000\u0000"+ + "\u0000\u03ba\u1ee4\u0001\u0000\u0000\u0000\u03bc\u1eed\u0001\u0000\u0000"+ + "\u0000\u03be\u1ef5\u0001\u0000\u0000\u0000\u03c0\u1ef9\u0001\u0000\u0000"+ + "\u0000\u03c2\u1f03\u0001\u0000\u0000\u0000\u03c4\u1f1a\u0001\u0000\u0000"+ + "\u0000\u03c6\u1f1c\u0001\u0000\u0000\u0000\u03c8\u1f26\u0001\u0000\u0000"+ + "\u0000\u03ca\u1f48\u0001\u0000\u0000\u0000\u03cc\u1f4a\u0001\u0000\u0000"+ + "\u0000\u03ce\u1f4d\u0001\u0000\u0000\u0000\u03d0\u1f53\u0001\u0000\u0000"+ + "\u0000\u03d2\u1f5b\u0001\u0000\u0000\u0000\u03d4\u1f67\u0001\u0000\u0000"+ + "\u0000\u03d6\u1f6b\u0001\u0000\u0000\u0000\u03d8\u1f75\u0001\u0000\u0000"+ + "\u0000\u03da\u1f79\u0001\u0000\u0000\u0000\u03dc\u1f89\u0001\u0000\u0000"+ + "\u0000\u03de\u1f8d\u0001\u0000\u0000\u0000\u03e0\u1f92\u0001\u0000\u0000"+ + "\u0000\u03e2\u1f94\u0001\u0000\u0000\u0000\u03e4\u1f9e\u0001\u0000\u0000"+ + "\u0000\u03e6\u1fa2\u0001\u0000\u0000\u0000\u03e8\u1fa4\u0001\u0000\u0000"+ + "\u0000\u03ea\u1fa8\u0001\u0000\u0000\u0000\u03ec\u1fb0\u0001\u0000\u0000"+ + "\u0000\u03ee\u1fc0\u0001\u0000\u0000\u0000\u03f0\u1fc4\u0001\u0000\u0000"+ + "\u0000\u03f2\u1fdd\u0001\u0000\u0000\u0000\u03f4\u1fdf\u0001\u0000\u0000"+ + "\u0000\u03f6\u1fe8\u0001\u0000\u0000\u0000\u03f8\u1fea\u0001\u0000\u0000"+ + "\u0000\u03fa\u1ff1\u0001\u0000\u0000\u0000\u03fc\u1ff5\u0001\u0000\u0000"+ + "\u0000\u03fe\u1ff7\u0001\u0000\u0000\u0000\u0400\u1ff9\u0001\u0000\u0000"+ + "\u0000\u0402\u1fff\u0001\u0000\u0000\u0000\u0404\u2001\u0001\u0000\u0000"+ + "\u0000\u0406\u200e\u0001\u0000\u0000\u0000\u0408\u2010\u0001\u0000\u0000"+ + "\u0000\u040a\u2013\u0001\u0000\u0000\u0000\u040c\u2018\u0001\u0000\u0000"+ + "\u0000\u040e\u201d\u0001\u0000\u0000\u0000\u0410\u2026\u0001\u0000\u0000"+ + "\u0000\u0412\u202c\u0001\u0000\u0000\u0000\u0414\u2030\u0001\u0000\u0000"+ + "\u0000\u0416\u2033\u0001\u0000\u0000\u0000\u0418\u2037\u0001\u0000\u0000"+ + "\u0000\u041a\u203b\u0001\u0000\u0000\u0000\u041c\u204a\u0001\u0000\u0000"+ + "\u0000\u041e\u204c\u0001\u0000\u0000\u0000\u0420\u205d\u0001\u0000\u0000"+ + "\u0000\u0422\u2068\u0001\u0000\u0000\u0000\u0424\u206a\u0001\u0000\u0000"+ + "\u0000\u0426\u20a2\u0001\u0000\u0000\u0000\u0428\u20ba\u0001\u0000\u0000"+ + "\u0000\u042a\u20c5\u0001\u0000\u0000\u0000\u042c\u20c8\u0001\u0000\u0000"+ + "\u0000\u042e\u20de\u0001\u0000\u0000\u0000\u0430\u20e0\u0001\u0000\u0000"+ + "\u0000\u0432\u20eb\u0001\u0000\u0000\u0000\u0434\u20f9\u0001\u0000\u0000"+ + "\u0000\u0436\u20fb\u0001\u0000\u0000\u0000\u0438\u2103\u0001\u0000\u0000"+ + "\u0000\u043a\u210a\u0001\u0000\u0000\u0000\u043c\u2117\u0001\u0000\u0000"+ + "\u0000\u043e\u2123\u0001\u0000\u0000\u0000\u0440\u2125\u0001\u0000\u0000"+ + "\u0000\u0442\u2128\u0001\u0000\u0000\u0000\u0444\u2136\u0001\u0000\u0000"+ + "\u0000\u0446\u213b\u0001\u0000\u0000\u0000\u0448\u2140\u0001\u0000\u0000"+ + "\u0000\u044a\u214a\u0001\u0000\u0000\u0000\u044c\u214e\u0001\u0000\u0000"+ + "\u0000\u044e\u2150\u0001\u0000\u0000\u0000\u0450\u2158\u0001\u0000\u0000"+ + "\u0000\u0452\u215c\u0001\u0000\u0000\u0000\u0454\u2171\u0001\u0000\u0000"+ + "\u0000\u0456\u2179\u0001\u0000\u0000\u0000\u0458\u2183\u0001\u0000\u0000"+ + "\u0000\u045a\u218f\u0001\u0000\u0000\u0000\u045c\u2191\u0001\u0000\u0000"+ + "\u0000\u045e\u219f\u0001\u0000\u0000\u0000\u0460\u21b3\u0001\u0000\u0000"+ + "\u0000\u0462\u21bc\u0001\u0000\u0000\u0000\u0464\u21cc\u0001\u0000\u0000"+ + "\u0000\u0466\u21d2\u0001\u0000\u0000\u0000\u0468\u21d8\u0001\u0000\u0000"+ + "\u0000\u046a\u21e4\u0001\u0000\u0000\u0000\u046c\u21f6\u0001\u0000\u0000"+ + "\u0000\u046e\u21fd\u0001\u0000\u0000\u0000\u0470\u2201\u0001\u0000\u0000"+ + "\u0000\u0472\u2205\u0001\u0000\u0000\u0000\u0474\u2207\u0001\u0000\u0000"+ + "\u0000\u0476\u220d\u0001\u0000\u0000\u0000\u0478\u2210\u0001\u0000\u0000"+ + "\u0000\u047a\u2217\u0001\u0000\u0000\u0000\u047c\u2224\u0001\u0000\u0000"+ + "\u0000\u047e\u2228\u0001\u0000\u0000\u0000\u0480\u222a\u0001\u0000\u0000"+ + "\u0000\u0482\u2233\u0001\u0000\u0000\u0000\u0484\u223c\u0001\u0000\u0000"+ + "\u0000\u0486\u2258\u0001\u0000\u0000\u0000\u0488\u225a\u0001\u0000\u0000"+ + "\u0000\u048a\u2264\u0001\u0000\u0000\u0000\u048c\u2266\u0001\u0000\u0000"+ + "\u0000\u048e\u2268\u0001\u0000\u0000\u0000\u0490\u226c\u0001\u0000\u0000"+ + "\u0000\u0492\u2274\u0001\u0000\u0000\u0000\u0494\u227c\u0001\u0000\u0000"+ + "\u0000\u0496\u2284\u0001\u0000\u0000\u0000\u0498\u2292\u0001\u0000\u0000"+ + "\u0000\u049a\u229b\u0001\u0000\u0000\u0000\u049c\u229f\u0001\u0000\u0000"+ + "\u0000\u049e\u22a3\u0001\u0000\u0000\u0000\u04a0\u22bd\u0001\u0000\u0000"+ + "\u0000\u04a2\u22cb\u0001\u0000\u0000\u0000\u04a4\u22da\u0001\u0000\u0000"+ + "\u0000\u04a6\u22e8\u0001\u0000\u0000\u0000\u04a8\u22ea\u0001\u0000\u0000"+ + "\u0000\u04aa\u22f2\u0001\u0000\u0000\u0000\u04ac\u22fa\u0001\u0000\u0000"+ + "\u0000\u04ae\u2300\u0001\u0000\u0000\u0000\u04b0\u2304\u0001\u0000\u0000"+ + "\u0000\u04b2\u230b\u0001\u0000\u0000\u0000\u04b4\u2310\u0001\u0000\u0000"+ + "\u0000\u04b6\u231f\u0001\u0000\u0000\u0000\u04b8\u236f\u0001\u0000\u0000"+ + "\u0000\u04ba\u2371\u0001\u0000\u0000\u0000\u04bc\u238f\u0001\u0000\u0000"+ + "\u0000\u04be\u2393\u0001\u0000\u0000\u0000\u04c0\u2446\u0001\u0000\u0000"+ + "\u0000\u04c2\u244d\u0001\u0000\u0000\u0000\u04c4\u245a\u0001\u0000\u0000"+ + "\u0000\u04c6\u245c\u0001\u0000\u0000\u0000\u04c8\u2461\u0001\u0000\u0000"+ + "\u0000\u04ca\u2469\u0001\u0000\u0000\u0000\u04cc\u246e\u0001\u0000\u0000"+ + "\u0000\u04ce\u2475\u0001\u0000\u0000\u0000\u04d0\u2486\u0001\u0000\u0000"+ + "\u0000\u04d2\u2488\u0001\u0000\u0000\u0000\u04d4\u2492\u0001\u0000\u0000"+ + "\u0000\u04d6\u249b\u0001\u0000\u0000\u0000\u04d8\u24a0\u0001\u0000\u0000"+ + "\u0000\u04da\u24a2\u0001\u0000\u0000\u0000\u04dc\u24aa\u0001\u0000\u0000"+ + "\u0000\u04de\u24b4\u0001\u0000\u0000\u0000\u04e0\u24b6\u0001\u0000\u0000"+ + "\u0000\u04e2\u24bf\u0001\u0000\u0000\u0000\u04e4\u24c5\u0001\u0000\u0000"+ + "\u0000\u04e6\u24d4\u0001\u0000\u0000\u0000\u04e8\u24dc\u0001\u0000\u0000"+ + "\u0000\u04ea\u24e5\u0001\u0000\u0000\u0000\u04ec\u24f1\u0001\u0000\u0000"+ + "\u0000\u04ee\u24ff\u0001\u0000\u0000\u0000\u04f0\u2501\u0001\u0000\u0000"+ + "\u0000\u04f2\u2508\u0001\u0000\u0000\u0000\u04f4\u250e\u0001\u0000\u0000"+ + "\u0000\u04f6\u2512\u0001\u0000\u0000\u0000\u04f8\u2514\u0001\u0000\u0000"+ + "\u0000\u04fa\u251c\u0001\u0000\u0000\u0000\u04fc\u2524\u0001\u0000\u0000"+ + "\u0000\u04fe\u2532\u0001\u0000\u0000\u0000\u0500\u2534\u0001\u0000\u0000"+ + "\u0000\u0502\u253c\u0001\u0000\u0000\u0000\u0504\u2549\u0001\u0000\u0000"+ + "\u0000\u0506\u254b\u0001\u0000\u0000\u0000\u0508\u2553\u0001\u0000\u0000"+ + "\u0000\u050a\u255a\u0001\u0000\u0000\u0000\u050c\u2567\u0001\u0000\u0000"+ + "\u0000\u050e\u2571\u0001\u0000\u0000\u0000\u0510\u2573\u0001\u0000\u0000"+ + "\u0000\u0512\u2575\u0001\u0000\u0000\u0000\u0514\u2583\u0001\u0000\u0000"+ + "\u0000\u0516\u25a0\u0001\u0000\u0000\u0000\u0518\u25a9\u0001\u0000\u0000"+ + "\u0000\u051a\u25b0\u0001\u0000\u0000\u0000\u051c\u25b2\u0001\u0000\u0000"+ + "\u0000\u051e\u25b9\u0001\u0000\u0000\u0000\u0520\u25bd\u0001\u0000\u0000"+ + "\u0000\u0522\u25c5\u0001\u0000\u0000\u0000\u0524\u25c9\u0001\u0000\u0000"+ + "\u0000\u0526\u25cb\u0001\u0000\u0000\u0000\u0528\u25de\u0001\u0000\u0000"+ + "\u0000\u052a\u25e2\u0001\u0000\u0000\u0000\u052c\u25e5\u0001\u0000\u0000"+ + "\u0000\u052e\u25ec\u0001\u0000\u0000\u0000\u0530\u25f1\u0001\u0000\u0000"+ + "\u0000\u0532\u25f3\u0001\u0000\u0000\u0000\u0534\u2603\u0001\u0000\u0000"+ + "\u0000\u0536\u2605\u0001\u0000\u0000\u0000\u0538\u260d\u0001\u0000\u0000"+ + "\u0000\u053a\u2611\u0001\u0000\u0000\u0000\u053c\u2619\u0001\u0000\u0000"+ + "\u0000\u053e\u261b\u0001\u0000\u0000\u0000\u0540\u261d\u0001\u0000\u0000"+ + "\u0000\u0542\u2626\u0001\u0000\u0000\u0000\u0544\u2648\u0001\u0000\u0000"+ + "\u0000\u0546\u264a\u0001\u0000\u0000\u0000\u0548\u264c\u0001\u0000\u0000"+ + "\u0000\u054a\u264e\u0001\u0000\u0000\u0000\u054c\u2650\u0001\u0000\u0000"+ + "\u0000\u054e\u2652\u0001\u0000\u0000\u0000\u0550\u2660\u0001\u0000\u0000"+ + "\u0000\u0552\u2665\u0001\u0000\u0000\u0000\u0554\u266c\u0001\u0000\u0000"+ + "\u0000\u0556\u266e\u0001\u0000\u0000\u0000\u0558\u2673\u0001\u0000\u0000"+ + "\u0000\u055a\u2675\u0001\u0000\u0000\u0000\u055c\u2683\u0001\u0000\u0000"+ + "\u0000\u055e\u2689\u0001\u0000\u0000\u0000\u0560\u268f\u0001\u0000\u0000"+ + "\u0000\u0562\u2695\u0001\u0000\u0000\u0000\u0564\u269d\u0001\u0000\u0000"+ + "\u0000\u0566\u26a5\u0001\u0000\u0000\u0000\u0568\u26a7\u0001\u0000\u0000"+ + "\u0000\u056a\u26a9\u0001\u0000\u0000\u0000\u056c\u26df\u0001\u0000\u0000"+ + "\u0000\u056e\u26e1\u0001\u0000\u0000\u0000\u0570\u26e3\u0001\u0000\u0000"+ + "\u0000\u0572\u26e5\u0001\u0000\u0000\u0000\u0574\u26e7\u0001\u0000\u0000"+ + "\u0000\u0576\u26ee\u0001\u0000\u0000\u0000\u0578\u2705\u0001\u0000\u0000"+ + "\u0000\u057a\u2707\u0001\u0000\u0000\u0000\u057c\u270d\u0001\u0000\u0000"+ + "\u0000\u057e\u2711\u0001\u0000\u0000\u0000\u0580\u2713\u0001\u0000\u0000"+ + "\u0000\u0582\u271a\u0001\u0000\u0000\u0000\u0584\u2721\u0001\u0000\u0000"+ + "\u0000\u0586\u2724\u0001\u0000\u0000\u0000\u0588\u2728\u0001\u0000\u0000"+ + "\u0000\u058a\u272f\u0001\u0000\u0000\u0000\u058c\u2731\u0001\u0000\u0000"+ + "\u0000\u058e\u2749\u0001\u0000\u0000\u0000\u0590\u274b\u0001\u0000\u0000"+ + "\u0000\u0592\u2752\u0001\u0000\u0000\u0000\u0594\u2754\u0001\u0000\u0000"+ + "\u0000\u0596\u275c\u0001\u0000\u0000\u0000\u0598\u275f\u0001\u0000\u0000"+ + "\u0000\u059a\u2763\u0001\u0000\u0000\u0000\u059c\u2765\u0001\u0000\u0000"+ + "\u0000\u059e\u2769\u0001\u0000\u0000\u0000\u05a0\u276b\u0001\u0000\u0000"+ + "\u0000\u05a2\u2770\u0001\u0000\u0000\u0000\u05a4\u2775\u0001\u0000\u0000"+ + "\u0000\u05a6\u277b\u0001\u0000\u0000\u0000\u05a8\u277f\u0001\u0000\u0000"+ + "\u0000\u05aa\u2781\u0001\u0000\u0000\u0000\u05ac\u2786\u0001\u0000\u0000"+ + "\u0000\u05ae\u27a4\u0001\u0000\u0000\u0000\u05b0\u27a6\u0001\u0000\u0000"+ + "\u0000\u05b2\u27b8\u0001\u0000\u0000\u0000\u05b4\u27bc\u0001\u0000\u0000"+ + "\u0000\u05b6\u27be\u0001\u0000\u0000\u0000\u05b8\u27c3\u0001\u0000\u0000"+ + "\u0000\u05ba\u27cc\u0001\u0000\u0000\u0000\u05bc\u27ce\u0001\u0000\u0000"+ + "\u0000\u05be\u27d6\u0001\u0000\u0000\u0000\u05c0\u27da\u0001\u0000\u0000"+ + "\u0000\u05c2\u27dc\u0001\u0000\u0000\u0000\u05c4\u27e0\u0001\u0000\u0000"+ + "\u0000\u05c6\u27eb\u0001\u0000\u0000\u0000\u05c8\u27fc\u0001\u0000\u0000"+ + "\u0000\u05ca\u2802\u0001\u0000\u0000\u0000\u05cc\u2804\u0001\u0000\u0000"+ + "\u0000\u05ce\u280e\u0001\u0000\u0000\u0000\u05d0\u2811\u0001\u0000\u0000"+ + "\u0000\u05d2\u2815\u0001\u0000\u0000\u0000\u05d4\u281d\u0001\u0000\u0000"+ + "\u0000\u05d6\u281f\u0001\u0000\u0000\u0000\u05d8\u2822\u0001\u0000\u0000"+ + "\u0000\u05da\u2827\u0001\u0000\u0000\u0000\u05dc\u282c\u0001\u0000\u0000"+ + "\u0000\u05de\u2842\u0001\u0000\u0000\u0000\u05e0\u2850\u0001\u0000\u0000"+ + "\u0000\u05e2\u2854\u0001\u0000\u0000\u0000\u05e4\u2859\u0001\u0000\u0000"+ + "\u0000\u05e6\u285b\u0001\u0000\u0000\u0000\u05e8\u285d\u0001\u0000\u0000"+ + "\u0000\u05ea\u2869\u0001\u0000\u0000\u0000\u05ec\u286b\u0001\u0000\u0000"+ + "\u0000\u05ee\u2870\u0001\u0000\u0000\u0000\u05f0\u2872\u0001\u0000\u0000"+ + "\u0000\u05f2\u2884\u0001\u0000\u0000\u0000\u05f4\u28a0\u0001\u0000\u0000"+ + "\u0000\u05f6\u28aa\u0001\u0000\u0000\u0000\u05f8\u28b3\u0001\u0000\u0000"+ + "\u0000\u05fa\u28b8\u0001\u0000\u0000\u0000\u05fc\u28ba\u0001\u0000\u0000"+ + "\u0000\u05fe\u28be\u0001\u0000\u0000\u0000\u0600\u28c6\u0001\u0000\u0000"+ + "\u0000\u0602\u28ce\u0001\u0000\u0000\u0000\u0604\u28d0\u0001\u0000\u0000"+ + "\u0000\u0606\u28d7\u0001\u0000\u0000\u0000\u0608\u28da\u0001\u0000\u0000"+ + "\u0000\u060a\u28ea\u0001\u0000\u0000\u0000\u060c\u28ec\u0001\u0000\u0000"+ + "\u0000\u060e\u28fa\u0001\u0000\u0000\u0000\u0610\u28fc\u0001\u0000\u0000"+ + "\u0000\u0612\u2917\u0001\u0000\u0000\u0000\u0614\u2919\u0001\u0000\u0000"+ + "\u0000\u0616\u2924\u0001\u0000\u0000\u0000\u0618\u292a\u0001\u0000\u0000"+ + "\u0000\u061a\u292e\u0001\u0000\u0000\u0000\u061c\u2930\u0001\u0000\u0000"+ + "\u0000\u061e\u2938\u0001\u0000\u0000\u0000\u0620\u293d\u0001\u0000\u0000"+ + "\u0000\u0622\u2950\u0001\u0000\u0000\u0000\u0624\u2952\u0001\u0000\u0000"+ + "\u0000\u0626\u2957\u0001\u0000\u0000\u0000\u0628\u295b\u0001\u0000\u0000"+ + "\u0000\u062a\u295e\u0001\u0000\u0000\u0000\u062c\u2962\u0001\u0000\u0000"+ + "\u0000\u062e\u296c\u0001\u0000\u0000\u0000\u0630\u297a\u0001\u0000\u0000"+ + "\u0000\u0632\u297e\u0001\u0000\u0000\u0000\u0634\u2983\u0001\u0000\u0000"+ + "\u0000\u0636\u2986\u0001\u0000\u0000\u0000\u0638\u298a\u0001\u0000\u0000"+ + "\u0000\u063a\u298f\u0001\u0000\u0000\u0000\u063c\u299a\u0001\u0000\u0000"+ + "\u0000\u063e\u299e\u0001\u0000\u0000\u0000\u0640\u29a2\u0001\u0000\u0000"+ + "\u0000\u0642\u29a6\u0001\u0000\u0000\u0000\u0644\u29ab\u0001\u0000\u0000"+ + "\u0000\u0646\u29af\u0001\u0000\u0000\u0000\u0648\u29b1\u0001\u0000\u0000"+ + "\u0000\u064a\u29b3\u0001\u0000\u0000\u0000\u064c\u29bb\u0001\u0000\u0000"+ + "\u0000\u064e\u29bd\u0001\u0000\u0000\u0000\u0650\u29bf\u0001\u0000\u0000"+ + "\u0000\u0652\u29c1\u0001\u0000\u0000\u0000\u0654\u29c3\u0001\u0000\u0000"+ + "\u0000\u0656\u29cb\u0001\u0000\u0000\u0000\u0658\u29d8\u0001\u0000\u0000"+ + "\u0000\u065a\u065b\u0003\u0004\u0002\u0000\u065b\u065c\u0005\u0000\u0000"+ + "\u0001\u065c\u0001\u0001\u0000\u0000\u0000\u065d\u065e\u0003\u0574\u02ba"+ + "\u0000\u065e\u0003\u0001\u0000\u0000\u0000\u065f\u0660\u0003\u0006\u0003"+ + "\u0000\u0660\u0005\u0001\u0000\u0000\u0000\u0661\u0663\u0003\b\u0004\u0000"+ + "\u0662\u0664\u0005\b\u0000\u0000\u0663\u0662\u0001\u0000\u0000\u0000\u0663"+ + "\u0664\u0001\u0000\u0000\u0000\u0664\u0666\u0001\u0000\u0000\u0000\u0665"+ + "\u0661\u0001\u0000\u0000\u0000\u0666\u0669\u0001\u0000\u0000\u0000\u0667"+ + "\u0665\u0001\u0000\u0000\u0000\u0667\u0668\u0001\u0000\u0000\u0000\u0668"+ + "\u0007\u0001\u0000\u0000\u0000\u0669\u0667\u0001\u0000\u0000\u0000\u066a"+ + "\u06e8\u0003\u01c4\u00e2\u0000\u066b\u06e8\u0003\u033a\u019d\u0000\u066c"+ + "\u06e8\u0003\u0330\u0198\u0000\u066d\u06e8\u0003\u0332\u0199\u0000\u066e"+ + "\u06e8\u0003\u0242\u0121\u0000\u066f\u06e8\u0003\u0340\u01a0\u0000\u0670"+ + "\u06e8\u0003\u01de\u00ef\u0000\u0671\u06e8\u0003\u0142\u00a1\u0000\u0672"+ + "\u06e8\u0003\u0148\u00a4\u0000\u0673\u06e8\u0003\u0152\u00a9\u0000\u0674"+ + "\u06e8\u0003\u016c\u00b6\u0000\u0675\u06e8\u0003\u029e\u014f\u0000\u0676"+ + "\u06e8\u0003&\u0013\u0000\u0677\u06e8\u0003\u02d8\u016c\u0000\u0678\u06e8"+ + "\u0003\u02dc\u016e\u0000\u0679\u06e8\u0003\u02e8\u0174\u0000\u067a\u06e8"+ + "\u0003\u02de\u016f\u0000\u067b\u06e8\u0003\u02e6\u0173\u0000\u067c\u06e8"+ + "\u0003\u0180\u00c0\u0000\u067d\u06e8\u0003\u0118\u008c\u0000\u067e\u06e8"+ + "\u0003\u033c\u019e\u0000\u067f\u06e8\u0003`0\u0000\u0680\u06e8\u0003\u02d0"+ + "\u0168\u0000\u0681\u06e8\u0003\u0086C\u0000\u0682\u06e8\u0003\u02f0\u0178"+ + "\u0000\u0683\u06e8\u0003 \u0010\u0000\u0684\u06e8\u0003\u001c\u000e\u0000"+ + "\u0685\u06e8\u0003\u02f8\u017c\u0000\u0686\u06e8\u0003\u0106\u0083\u0000"+ + "\u0687\u06e8\u0003\u0346\u01a3\u0000\u0688\u06e8\u0003\u0344\u01a2\u0000"+ + "\u0689\u06e8\u0003\u017c\u00be\u0000\u068a\u06e8\u0003\u0352\u01a9\u0000"+ + "\u068b\u06e8\u0003\f\u0006\u0000\u068c\u06e8\u0003\\.\u0000\u068d\u06e8"+ + "\u0003\u008cF\u0000\u068e\u06e8\u0003\u034c\u01a6\u0000\u068f\u06e8\u0003"+ + "\u0216\u010b\u0000\u0690\u06e8\u0003V+\u0000\u0691\u06e8\u0003\u008eG"+ + "\u0000\u0692\u06e8\u0003\u0190\u00c8\u0000\u0693\u06e8\u0003\u0108\u0084"+ + "\u0000\u0694\u06e8\u0003\u01c8\u00e4\u0000\u0695\u06e8\u0003\u02b8\u015c"+ + "\u0000\u0696\u06e8\u0003\u034a\u01a5\u0000\u0697\u06e8\u0003\u033e\u019f"+ + "\u0000\u0698\u06e8\u0003\u013c\u009e\u0000\u0699\u06e8\u0003\u014a\u00a5"+ + "\u0000\u069a\u06e8\u0003\u0164\u00b2\u0000\u069b\u06e8\u0003\u016e\u00b7"+ + "\u0000\u069c\u06e8\u0003\u0268\u0134\u0000\u069d\u06e8\u0003$\u0012\u0000"+ + "\u069e\u06e8\u0003\u010e\u0087\u0000\u069f\u06e8\u0003\u01e2\u00f1\u0000"+ + "\u06a0\u06e8\u0003\u01f0\u00f8\u0000\u06a1\u06e8\u0003\u02ea\u0175\u0000"+ + "\u06a2\u06e8\u0003\u01f2\u00f9\u0000\u06a3\u06e8\u0003\u017e\u00bf\u0000"+ + "\u06a4\u06e8\u0003\u0128\u0094\u0000\u06a5\u06e8\u0003*\u0015\u0000\u06a6"+ + "\u06e8\u0003\u0116\u008b\u0000\u06a7\u06e8\u0003\u00acV\u0000\u06a8\u06e8"+ + "\u0003\u02f2\u0179\u0000\u06a9\u06e8\u0003\u0104\u0082\u0000\u06aa\u06e8"+ + "\u0003\u0136\u009b\u0000\u06ab\u06e8\u0003\u02c0\u0160\u0000\u06ac\u06e8"+ + "\u0003\u0194\u00ca\u0000\u06ad\u06e8\u0003\u01bc\u00de\u0000\u06ae\u06e8"+ + "\u0003\u000e\u0007\u0000\u06af\u06e8\u0003\u001a\r\u0000\u06b0\u06e8\u0003"+ + "\u0176\u00bb\u0000\u06b1\u06e8\u0003\u0324\u0192\u0000\u06b2\u06e8\u0003"+ + "\u0384\u01c2\u0000\u06b3\u06e8\u0003\u03b8\u01dc\u0000\u06b4\u06e8\u0003"+ + "\u01ca\u00e5\u0000\u06b5\u06e8\u0003\u03a0\u01d0\u0000\u06b6\u06e8\u0003"+ + "^/\u0000\u06b7\u06e8\u0003\u02b2\u0159\u0000\u06b8\u06e8\u0003\u02bc\u015e"+ + "\u0000\u06b9\u06e8\u0003\u01f8\u00fc\u0000\u06ba\u06e8\u0003\u01fa\u00fd"+ + "\u0000\u06bb\u06e8\u0003\u01fc\u00fe\u0000\u06bc\u06e8\u0003\u0200\u0100"+ + "\u0000\u06bd\u06e8\u0003\u02fa\u017d\u0000\u06be\u06e8\u0003\u013a\u009d"+ + "\u0000\u06bf\u06e8\u0003\u02c4\u0162\u0000\u06c0\u06e8\u0003\"\u0011\u0000"+ + "\u06c1\u06e8\u0003\u017a\u00bd\u0000\u06c2\u06e8\u0003\u0334\u019a\u0000"+ + "\u06c3\u06e8\u0003\u0380\u01c0\u0000\u06c4\u06e8\u0003\u036e\u01b7\u0000"+ + "\u06c5\u06e8\u0003\u0220\u0110\u0000\u06c6\u06e8\u0003\u0228\u0114\u0000"+ + "\u06c7\u06e8\u0003\u023a\u011d\u0000\u06c8\u06e8\u0003\u0170\u00b8\u0000"+ + "\u06c9\u06e8\u0003\u024c\u0126\u0000\u06ca\u06e8\u0003\u0386\u01c3\u0000"+ + "\u06cb\u06e8\u0003\u0398\u01cc\u0000\u06cc\u06e8\u0003\u030e\u0187\u0000"+ + "\u06cd\u06e8\u0003\u0114\u008a\u0000\u06ce\u06e8\u0003\u0322\u0191\u0000"+ + "\u06cf\u06e8\u0003\u03a4\u01d2\u0000\u06d0\u06e8\u0003\u030a\u0185\u0000"+ + "\u06d1\u06e8\u0003\u037a\u01bd\u0000\u06d2\u06e8\u0003\u01fe\u00ff\u0000"+ + "\u06d3\u06e8\u0003\u02c6\u0163\u0000\u06d4\u06e8\u0003\u02a6\u0153\u0000"+ + "\u06d5\u06e8\u0003\u02a4\u0152\u0000\u06d6\u06e8\u0003\u02a8\u0154\u0000"+ + "\u06d7\u06e8\u0003\u02d2\u0169\u0000\u06d8\u06e8\u0003\u022a\u0115\u0000"+ + "\u06d9\u06e8\u0003\u023c\u011e\u0000\u06da\u06e8\u0003\u02fc\u017e\u0000"+ + "\u06db\u06e8\u0003\u021a\u010d\u0000\u06dc\u06e8\u0003\u03c0\u01e0\u0000"+ + "\u06dd\u06e8\u0003\u0312\u0189\u0000\u06de\u06e8\u0003\u0212\u0109\u0000"+ + "\u06df\u06e8\u0003\u0310\u0188\u0000\u06e0\u06e8\u0003\u03ae\u01d7\u0000"+ + "\u06e1\u06e8\u0003\u0350\u01a8\u0000\u06e2\u06e8\u0003J%\u0000\u06e3\u06e8"+ + "\u00032\u0019\u0000\u06e4\u06e8\u0003T*\u0000\u06e5\u06e8\u0003\u031e"+ + "\u018f\u0000\u06e6\u06e8\u0003\n\u0005\u0000\u06e7\u066a\u0001\u0000\u0000"+ + "\u0000\u06e7\u066b\u0001\u0000\u0000\u0000\u06e7\u066c\u0001\u0000\u0000"+ + "\u0000\u06e7\u066d\u0001\u0000\u0000\u0000\u06e7\u066e\u0001\u0000\u0000"+ + "\u0000\u06e7\u066f\u0001\u0000\u0000\u0000\u06e7\u0670\u0001\u0000\u0000"+ + "\u0000\u06e7\u0671\u0001\u0000\u0000\u0000\u06e7\u0672\u0001\u0000\u0000"+ + "\u0000\u06e7\u0673\u0001\u0000\u0000\u0000\u06e7\u0674\u0001\u0000\u0000"+ + "\u0000\u06e7\u0675\u0001\u0000\u0000\u0000\u06e7\u0676\u0001\u0000\u0000"+ + "\u0000\u06e7\u0677\u0001\u0000\u0000\u0000\u06e7\u0678\u0001\u0000\u0000"+ + "\u0000\u06e7\u0679\u0001\u0000\u0000\u0000\u06e7\u067a\u0001\u0000\u0000"+ + "\u0000\u06e7\u067b\u0001\u0000\u0000\u0000\u06e7\u067c\u0001\u0000\u0000"+ + "\u0000\u06e7\u067d\u0001\u0000\u0000\u0000\u06e7\u067e\u0001\u0000\u0000"+ + "\u0000\u06e7\u067f\u0001\u0000\u0000\u0000\u06e7\u0680\u0001\u0000\u0000"+ + "\u0000\u06e7\u0681\u0001\u0000\u0000\u0000\u06e7\u0682\u0001\u0000\u0000"+ + "\u0000\u06e7\u0683\u0001\u0000\u0000\u0000\u06e7\u0684\u0001\u0000\u0000"+ + "\u0000\u06e7\u0685\u0001\u0000\u0000\u0000\u06e7\u0686\u0001\u0000\u0000"+ + "\u0000\u06e7\u0687\u0001\u0000\u0000\u0000\u06e7\u0688\u0001\u0000\u0000"+ + "\u0000\u06e7\u0689\u0001\u0000\u0000\u0000\u06e7\u068a\u0001\u0000\u0000"+ + "\u0000\u06e7\u068b\u0001\u0000\u0000\u0000\u06e7\u068c\u0001\u0000\u0000"+ + "\u0000\u06e7\u068d\u0001\u0000\u0000\u0000\u06e7\u068e\u0001\u0000\u0000"+ + "\u0000\u06e7\u068f\u0001\u0000\u0000\u0000\u06e7\u0690\u0001\u0000\u0000"+ + "\u0000\u06e7\u0691\u0001\u0000\u0000\u0000\u06e7\u0692\u0001\u0000\u0000"+ + "\u0000\u06e7\u0693\u0001\u0000\u0000\u0000\u06e7\u0694\u0001\u0000\u0000"+ + "\u0000\u06e7\u0695\u0001\u0000\u0000\u0000\u06e7\u0696\u0001\u0000\u0000"+ + "\u0000\u06e7\u0697\u0001\u0000\u0000\u0000\u06e7\u0698\u0001\u0000\u0000"+ + "\u0000\u06e7\u0699\u0001\u0000\u0000\u0000\u06e7\u069a\u0001\u0000\u0000"+ + "\u0000\u06e7\u069b\u0001\u0000\u0000\u0000\u06e7\u069c\u0001\u0000\u0000"+ + "\u0000\u06e7\u069d\u0001\u0000\u0000\u0000\u06e7\u069e\u0001\u0000\u0000"+ + "\u0000\u06e7\u069f\u0001\u0000\u0000\u0000\u06e7\u06a0\u0001\u0000\u0000"+ + "\u0000\u06e7\u06a1\u0001\u0000\u0000\u0000\u06e7\u06a2\u0001\u0000\u0000"+ + "\u0000\u06e7\u06a3\u0001\u0000\u0000\u0000\u06e7\u06a4\u0001\u0000\u0000"+ + "\u0000\u06e7\u06a5\u0001\u0000\u0000\u0000\u06e7\u06a6\u0001\u0000\u0000"+ + "\u0000\u06e7\u06a7\u0001\u0000\u0000\u0000\u06e7\u06a8\u0001\u0000\u0000"+ + "\u0000\u06e7\u06a9\u0001\u0000\u0000\u0000\u06e7\u06aa\u0001\u0000\u0000"+ + "\u0000\u06e7\u06ab\u0001\u0000\u0000\u0000\u06e7\u06ac\u0001\u0000\u0000"+ + "\u0000\u06e7\u06ad\u0001\u0000\u0000\u0000\u06e7\u06ae\u0001\u0000\u0000"+ + "\u0000\u06e7\u06af\u0001\u0000\u0000\u0000\u06e7\u06b0\u0001\u0000\u0000"+ + "\u0000\u06e7\u06b1\u0001\u0000\u0000\u0000\u06e7\u06b2\u0001\u0000\u0000"+ + "\u0000\u06e7\u06b3\u0001\u0000\u0000\u0000\u06e7\u06b4\u0001\u0000\u0000"+ + "\u0000\u06e7\u06b5\u0001\u0000\u0000\u0000\u06e7\u06b6\u0001\u0000\u0000"+ + "\u0000\u06e7\u06b7\u0001\u0000\u0000\u0000\u06e7\u06b8\u0001\u0000\u0000"+ + "\u0000\u06e7\u06b9\u0001\u0000\u0000\u0000\u06e7\u06ba\u0001\u0000\u0000"+ + "\u0000\u06e7\u06bb\u0001\u0000\u0000\u0000\u06e7\u06bc\u0001\u0000\u0000"+ + "\u0000\u06e7\u06bd\u0001\u0000\u0000\u0000\u06e7\u06be\u0001\u0000\u0000"+ + "\u0000\u06e7\u06bf\u0001\u0000\u0000\u0000\u06e7\u06c0\u0001\u0000\u0000"+ + "\u0000\u06e7\u06c1\u0001\u0000\u0000\u0000\u06e7\u06c2\u0001\u0000\u0000"+ + "\u0000\u06e7\u06c3\u0001\u0000\u0000\u0000\u06e7\u06c4\u0001\u0000\u0000"+ + "\u0000\u06e7\u06c5\u0001\u0000\u0000\u0000\u06e7\u06c6\u0001\u0000\u0000"+ + "\u0000\u06e7\u06c7\u0001\u0000\u0000\u0000\u06e7\u06c8\u0001\u0000\u0000"+ + "\u0000\u06e7\u06c9\u0001\u0000\u0000\u0000\u06e7\u06ca\u0001\u0000\u0000"+ + "\u0000\u06e7\u06cb\u0001\u0000\u0000\u0000\u06e7\u06cc\u0001\u0000\u0000"+ + "\u0000\u06e7\u06cd\u0001\u0000\u0000\u0000\u06e7\u06ce\u0001\u0000\u0000"+ + "\u0000\u06e7\u06cf\u0001\u0000\u0000\u0000\u06e7\u06d0\u0001\u0000\u0000"+ + "\u0000\u06e7\u06d1\u0001\u0000\u0000\u0000\u06e7\u06d2\u0001\u0000\u0000"+ + "\u0000\u06e7\u06d3\u0001\u0000\u0000\u0000\u06e7\u06d4\u0001\u0000\u0000"+ + "\u0000\u06e7\u06d5\u0001\u0000\u0000\u0000\u06e7\u06d6\u0001\u0000\u0000"+ + "\u0000\u06e7\u06d7\u0001\u0000\u0000\u0000\u06e7\u06d8\u0001\u0000\u0000"+ + "\u0000\u06e7\u06d9\u0001\u0000\u0000\u0000\u06e7\u06da\u0001\u0000\u0000"+ + "\u0000\u06e7\u06db\u0001\u0000\u0000\u0000\u06e7\u06dc\u0001\u0000\u0000"+ + "\u0000\u06e7\u06dd\u0001\u0000\u0000\u0000\u06e7\u06de\u0001\u0000\u0000"+ + "\u0000\u06e7\u06df\u0001\u0000\u0000\u0000\u06e7\u06e0\u0001\u0000\u0000"+ + "\u0000\u06e7\u06e1\u0001\u0000\u0000\u0000\u06e7\u06e2\u0001\u0000\u0000"+ + "\u0000\u06e7\u06e3\u0001\u0000\u0000\u0000\u06e7\u06e4\u0001\u0000\u0000"+ + "\u0000\u06e7\u06e5\u0001\u0000\u0000\u0000\u06e7\u06e6\u0001\u0000\u0000"+ + "\u0000\u06e8\t\u0001\u0000\u0000\u0000\u06e9\u06eb\u0005\u029e\u0000\u0000"+ + "\u06ea\u06ec\u0005\u029f\u0000\u0000\u06eb\u06ea\u0001\u0000\u0000\u0000"+ + "\u06eb\u06ec\u0001\u0000\u0000\u0000\u06ec\u000b\u0001\u0000\u0000\u0000"+ + "\u06ed\u06ee\u0005\u01b3\u0000\u0000\u06ee\u06ef\u0003\u04ba\u025d\u0000"+ + "\u06ef\r\u0001\u0000\u0000\u0000\u06f0\u06f1\u00050\u0000\u0000\u06f1"+ + "\u06f2\u0005\u0139\u0000\u0000\u06f2\u06f3\u0003\u0556\u02ab\u0000\u06f3"+ + "\u06f4\u0003\u0010\b\u0000\u06f4\u06f5\u0003\u0012\t\u0000\u06f5\u000f"+ + "\u0001\u0000\u0000\u0000\u06f6\u06f9\u0005k\u0000\u0000\u06f7\u06f9\u0001"+ + "\u0000\u0000\u0000\u06f8\u06f6\u0001\u0000\u0000\u0000\u06f8\u06f7\u0001"+ + "\u0000\u0000\u0000\u06f9\u0011\u0001\u0000\u0000\u0000\u06fa\u06fc\u0003"+ + "\u0018\f\u0000\u06fb\u06fa\u0001\u0000\u0000\u0000\u06fc\u06ff\u0001\u0000"+ + "\u0000\u0000\u06fd\u06fb\u0001\u0000\u0000\u0000\u06fd\u06fe\u0001\u0000"+ + "\u0000\u0000\u06fe\u0013\u0001\u0000\u0000\u0000\u06ff\u06fd\u0001\u0000"+ + "\u0000\u0000\u0700\u0702\u0003\u0016\u000b\u0000\u0701\u0700\u0001\u0000"+ + "\u0000\u0000\u0702\u0705\u0001\u0000\u0000\u0000\u0703\u0701\u0001\u0000"+ + "\u0000\u0000\u0703\u0704\u0001\u0000\u0000\u0000\u0704\u0015\u0001\u0000"+ + "\u0000\u0000\u0705\u0703\u0001\u0000\u0000\u0000\u0706\u0709\u0005\u011a"+ + "\u0000\u0000\u0707\u070a\u0003\u054e\u02a7\u0000\u0708\u070a\u0005P\u0000"+ + "\u0000\u0709\u0707\u0001\u0000\u0000\u0000\u0709\u0708\u0001\u0000\u0000"+ + "\u0000\u070a\u0719\u0001\u0000\u0000\u0000\u070b\u070c\u0007\u0000\u0000"+ + "\u0000\u070c\u070d\u0005\u011a\u0000\u0000\u070d\u0719\u0003\u054e\u02a7"+ + "\u0000\u070e\u0719\u0005\u00e6\u0000\u0000\u070f\u0710\u0005\u00a6\u0000"+ + "\u0000\u0710\u0711\u0005L\u0000\u0000\u0711\u0719\u0003\u0554\u02aa\u0000"+ + "\u0712\u0713\u0005\u016e\u0000\u0000\u0713\u0714\u0005\u016b\u0000\u0000"+ + "\u0714\u0719\u0003\u054e\u02a7\u0000\u0715\u0716\u0005e\u0000\u0000\u0716"+ + "\u0719\u0003\u055a\u02ad\u0000\u0717\u0719\u0003\u0566\u02b3\u0000\u0718"+ + "\u0706\u0001\u0000\u0000\u0000\u0718\u070b\u0001\u0000\u0000\u0000\u0718"+ + "\u070e\u0001\u0000\u0000\u0000\u0718\u070f\u0001\u0000\u0000\u0000\u0718"+ + "\u0712\u0001\u0000\u0000\u0000\u0718\u0715\u0001\u0000\u0000\u0000\u0718"+ + "\u0717\u0001\u0000\u0000\u0000\u0719\u0017\u0001\u0000\u0000\u0000\u071a"+ + "\u0725\u0003\u0016\u000b\u0000\u071b\u071c\u0005\u0157\u0000\u0000\u071c"+ + "\u0725\u0003\u054c\u02a6\u0000\u071d\u071e\u0005\u0088\u0000\u0000\u071e"+ + "\u0725\u0003\u055a\u02ad\u0000\u071f\u0720\u0005\u0139\u0000\u0000\u0720"+ + "\u0725\u0003\u055a\u02ad\u0000\u0721\u0722\u0005F\u0000\u0000\u0722\u0723"+ + "\u0007\u0001\u0000\u0000\u0723\u0725\u0003\u055a\u02ad\u0000\u0724\u071a"+ + "\u0001\u0000\u0000\u0000\u0724\u071b\u0001\u0000\u0000\u0000\u0724\u071d"+ + "\u0001\u0000\u0000\u0000\u0724\u071f\u0001\u0000\u0000\u0000\u0724\u0721"+ + "\u0001\u0000\u0000\u0000\u0725\u0019\u0001\u0000\u0000\u0000\u0726\u0727"+ + "\u00050\u0000\u0000\u0727\u0728\u0005e\u0000\u0000\u0728\u0729\u0003\u0556"+ + "\u02ab\u0000\u0729\u072a\u0003\u0010\b\u0000\u072a\u072b\u0003\u0012\t"+ + "\u0000\u072b\u001b\u0001\u0000\u0000\u0000\u072c\u072d\u0005\u008c\u0000"+ + "\u0000\u072d\u072e\u0007\u0002\u0000\u0000\u072e\u072f\u0003\u0558\u02ac"+ + "\u0000\u072f\u0730\u0003\u0010\b\u0000\u0730\u0731\u0003\u0014\n\u0000"+ + "\u0731\u001d\u0001\u0000\u0000\u0000\u0732\u0737\u0001\u0000\u0000\u0000"+ + "\u0733\u0734\u0005F\u0000\u0000\u0734\u0735\u0005\u00b1\u0000\u0000\u0735"+ + "\u0737\u0003\u053c\u029e\u0000\u0736\u0732\u0001\u0000\u0000\u0000\u0736"+ + "\u0733\u0001\u0000\u0000\u0000\u0737\u001f\u0001\u0000\u0000\u0000\u0738"+ + "\u0739\u0005\u008c\u0000\u0000\u0739\u073b\u0007\u0002\u0000\u0000\u073a"+ + "\u073c\u0005 \u0000\u0000\u073b\u073a\u0001\u0000\u0000\u0000\u073b\u073c"+ + "\u0001\u0000\u0000\u0000\u073c\u073d\u0001\u0000\u0000\u0000\u073d\u073e"+ + "\u0003\u0558\u02ac\u0000\u073e\u073f\u0003\u001e\u000f\u0000\u073f\u0740"+ + "\u0003P(\u0000\u0740!\u0001\u0000\u0000\u0000\u0741\u0742\u0005\u00c1"+ + "\u0000\u0000\u0742\u0745\u0007\u0003\u0000\u0000\u0743\u0744\u0005\u00de"+ + "\u0000\u0000\u0744\u0746\u0005\u0187\u0000\u0000\u0745\u0743\u0001\u0000"+ + "\u0000\u0000\u0745\u0746\u0001\u0000\u0000\u0000\u0746\u0747\u0001\u0000"+ + "\u0000\u0000\u0747\u0748\u0003\u055a\u02ad\u0000\u0748#\u0001\u0000\u0000"+ + "\u0000\u0749\u074a\u00050\u0000\u0000\u074a\u074b\u0005D\u0000\u0000\u074b"+ + "\u074c\u0003\u0556\u02ab\u0000\u074c\u074d\u0003\u0010\b\u0000\u074d\u074e"+ + "\u0003\u0012\t\u0000\u074e%\u0001\u0000\u0000\u0000\u074f\u0750\u0005"+ + "\u008c\u0000\u0000\u0750\u0751\u0005D\u0000\u0000\u0751\u0752\u0003\u0558"+ + "\u02ac\u0000\u0752\u0753\u0003(\u0014\u0000\u0753\u0754\u0005e\u0000\u0000"+ + "\u0754\u0755\u0003\u055a\u02ad\u0000\u0755\'\u0001\u0000\u0000\u0000\u0756"+ + "\u0757\u0007\u0004\u0000\u0000\u0757)\u0001\u0000\u0000\u0000\u0758\u0759"+ + "\u00050\u0000\u0000\u0759\u075d\u0005\u013e\u0000\u0000\u075a\u075b\u0005"+ + "\u00de\u0000\u0000\u075b\u075c\u0005O\u0000\u0000\u075c\u075e\u0005\u0187"+ + "\u0000\u0000\u075d\u075a\u0001\u0000\u0000\u0000\u075d\u075e\u0001\u0000"+ + "\u0000\u0000\u075e\u0764\u0001\u0000\u0000\u0000\u075f\u0760\u0003,\u0016"+ + "\u0000\u0760\u0761\u0005l\u0000\u0000\u0761\u0762\u0003\u0558\u02ac\u0000"+ + "\u0762\u0765\u0001\u0000\u0000\u0000\u0763\u0765\u0003\u055c\u02ae\u0000"+ + "\u0764\u075f\u0001\u0000\u0000\u0000\u0764\u0763\u0001\u0000\u0000\u0000"+ + "\u0765\u0766\u0001\u0000\u0000\u0000\u0766\u0767\u0003.\u0017\u0000\u0767"+ + "+\u0001\u0000\u0000\u0000\u0768\u076b\u0003\u055c\u02ae\u0000\u0769\u076b"+ + "\u0001\u0000\u0000\u0000\u076a\u0768\u0001\u0000\u0000\u0000\u076a\u0769"+ + "\u0001\u0000\u0000\u0000\u076b-\u0001\u0000\u0000\u0000\u076c\u076e\u0003"+ + "0\u0018\u0000\u076d\u076c\u0001\u0000\u0000\u0000\u076e\u0771\u0001\u0000"+ + "\u0000\u0000\u076f\u076d\u0001\u0000\u0000\u0000\u076f\u0770\u0001\u0000"+ + "\u0000\u0000\u0770/\u0001\u0000\u0000\u0000\u0771\u076f\u0001\u0000\u0000"+ + "\u0000\u0772\u0779\u0003\u00acV\u0000\u0773\u0779\u0003\u024c\u0126\u0000"+ + "\u0774\u0779\u0003\u0116\u008b\u0000\u0775\u0779\u0003\u0194\u00ca\u0000"+ + "\u0776\u0779\u0003\u0228\u0114\u0000\u0777\u0779\u0003\u031e\u018f\u0000"+ + "\u0778\u0772\u0001\u0000\u0000\u0000\u0778\u0773\u0001\u0000\u0000\u0000"+ + "\u0778\u0774\u0001\u0000\u0000\u0000\u0778\u0775\u0001\u0000\u0000\u0000"+ + "\u0778\u0776\u0001\u0000\u0000\u0000\u0778\u0777\u0001\u0000\u0000\u0000"+ + "\u07791\u0001\u0000\u0000\u0000\u077a\u077c\u0005\u0148\u0000\u0000\u077b"+ + "\u077d\u0007\u0005\u0000\u0000\u077c\u077b\u0001\u0000\u0000\u0000\u077c"+ + "\u077d\u0001\u0000\u0000\u0000\u077d\u077e\u0001\u0000\u0000\u0000\u077e"+ + "\u077f\u00034\u001a\u0000\u077f3\u0001\u0000\u0000\u0000\u0780\u0781\u0005"+ + "\u015f\u0000\u0000\u0781\u0789\u0003\u0318\u018c\u0000\u0782\u0783\u0005"+ + "\u0147\u0000\u0000\u0783\u0784\u0005\u009c\u0000\u0000\u0784\u0785\u0005"+ + "&\u0000\u0000\u0785\u0786\u0005\u015f\u0000\u0000\u0786\u0789\u0003\u0318"+ + "\u018c\u0000\u0787\u0789\u00038\u001c\u0000\u0788\u0780\u0001\u0000\u0000"+ + "\u0000\u0788\u0782\u0001\u0000\u0000\u0000\u0788\u0787\u0001\u0000\u0000"+ + "\u0000\u07895\u0001\u0000\u0000\u0000\u078a\u078b\u0003:\u001d\u0000\u078b"+ + "\u078c\u0007\u0006\u0000\u0000\u078c\u078d\u0003<\u001e\u0000\u078d7\u0001"+ + "\u0000\u0000\u0000\u078e\u07a8\u00036\u001b\u0000\u078f\u0790\u0003:\u001d"+ + "\u0000\u0790\u0791\u0005B\u0000\u0000\u0791\u0792\u0005\u01b4\u0000\u0000"+ + "\u0792\u07a8\u0001\u0000\u0000\u0000\u0793\u0794\u0005\u019d\u0000\u0000"+ + "\u0794\u0795\u0005\u017d\u0000\u0000\u0795\u07a8\u0003D\"\u0000\u0796"+ + "\u0797\u0005\u009a\u0000\u0000\u0797\u07a8\u0003\u054e\u02a7\u0000\u0798"+ + "\u0799\u0005\u013e\u0000\u0000\u0799\u07a8\u0003\u054e\u02a7\u0000\u079a"+ + "\u079b\u0005\u0106\u0000\u0000\u079b\u07a8\u0003F#\u0000\u079c\u079d\u0005"+ + "\u0139\u0000\u0000\u079d\u07a8\u0003H$\u0000\u079e\u079f\u0005\u0147\u0000"+ + "\u0000\u079f\u07a0\u0005l\u0000\u0000\u07a0\u07a8\u0003H$\u0000\u07a1"+ + "\u07a2\u0005\u017a\u0000\u0000\u07a2\u07a3\u0005\u0112\u0000\u0000\u07a3"+ + "\u07a8\u0003\u04cc\u0266\u0000\u07a4\u07a5\u0005\u015f\u0000\u0000\u07a5"+ + "\u07a6\u0005\u014c\u0000\u0000\u07a6\u07a8\u0003\u054e\u02a7\u0000\u07a7"+ + "\u078e\u0001\u0000\u0000\u0000\u07a7\u078f\u0001\u0000\u0000\u0000\u07a7"+ + "\u0793\u0001\u0000\u0000\u0000\u07a7\u0796\u0001\u0000\u0000\u0000\u07a7"+ + "\u0798\u0001\u0000\u0000\u0000\u07a7\u079a\u0001\u0000\u0000\u0000\u07a7"+ + "\u079c\u0001\u0000\u0000\u0000\u07a7\u079e\u0001\u0000\u0000\u0000\u07a7"+ + "\u07a1\u0001\u0000\u0000\u0000\u07a7\u07a4\u0001\u0000\u0000\u0000\u07a8"+ + "9\u0001\u0000\u0000\u0000\u07a9\u07ae\u0003\u055c\u02ae\u0000\u07aa\u07ab"+ + "\u0005\r\u0000\u0000\u07ab\u07ad\u0003\u055c\u02ae\u0000\u07ac\u07aa\u0001"+ + "\u0000\u0000\u0000\u07ad\u07b0\u0001\u0000\u0000\u0000\u07ae\u07ac\u0001"+ + "\u0000\u0000\u0000\u07ae\u07af\u0001\u0000\u0000\u0000\u07af;\u0001\u0000"+ + "\u0000\u0000\u07b0\u07ae\u0001\u0000\u0000\u0000\u07b1\u07b6\u0003>\u001f"+ + "\u0000\u07b2\u07b3\u0005\u0007\u0000\u0000\u07b3\u07b5\u0003>\u001f\u0000"+ + "\u07b4\u07b2\u0001\u0000\u0000\u0000\u07b5\u07b8\u0001\u0000\u0000\u0000"+ + "\u07b6\u07b4\u0001\u0000\u0000\u0000\u07b6\u07b7\u0001\u0000\u0000\u0000"+ + "\u07b7=\u0001\u0000\u0000\u0000\u07b8\u07b6\u0001\u0000\u0000\u0000\u07b9"+ + "\u07bc\u0003B!\u0000\u07ba\u07bc\u0003\u0124\u0092\u0000\u07bb\u07b9\u0001"+ + "\u0000\u0000\u0000\u07bb\u07ba\u0001\u0000\u0000\u0000\u07bc?\u0001\u0000"+ + "\u0000\u0000\u07bd\u07be\u0005\u0127\u0000\u0000\u07be\u07c3\u0007\u0007"+ + "\u0000\u0000\u07bf\u07c0\u0005\u0131\u0000\u0000\u07c0\u07c3\u0005\u0127"+ + "\u0000\u0000\u07c1\u07c3\u0005\u0145\u0000\u0000\u07c2\u07bd\u0001\u0000"+ + "\u0000\u0000\u07c2\u07bf\u0001\u0000\u0000\u0000\u07c2\u07c1\u0001\u0000"+ + "\u0000\u0000\u07c3A\u0001\u0000\u0000\u0000\u07c4\u07c9\u0005b\u0000\u0000"+ + "\u07c5\u07c9\u0005>\u0000\u0000\u07c6\u07c9\u0005R\u0000\u0000\u07c7\u07c9"+ + "\u0003H$\u0000\u07c8\u07c4\u0001\u0000\u0000\u0000\u07c8\u07c5\u0001\u0000"+ + "\u0000\u0000\u07c8\u07c6\u0001\u0000\u0000\u0000\u07c8\u07c7\u0001\u0000"+ + "\u0000\u0000\u07c9C\u0001\u0000\u0000\u0000\u07ca\u07da\u0003\u054e\u02a7"+ + "\u0000\u07cb\u07da\u0003\u0566\u02b3\u0000\u07cc\u07cd\u0003\u0482\u0241"+ + "\u0000\u07cd\u07ce\u0003\u054e\u02a7\u0000\u07ce\u07cf\u0003\u0486\u0243"+ + "\u0000\u07cf\u07da\u0001\u0000\u0000\u0000\u07d0\u07d1\u0003\u0482\u0241"+ + "\u0000\u07d1\u07d2\u0005\u0003\u0000\u0000\u07d2\u07d3\u0003\u054c\u02a6"+ + "\u0000\u07d3\u07d4\u0005\u0004\u0000\u0000\u07d4\u07d5\u0003\u054e\u02a7"+ + "\u0000\u07d5\u07da\u0001\u0000\u0000\u0000\u07d6\u07da\u0003\u0124\u0092"+ + "\u0000\u07d7\u07da\u00057\u0000\u0000\u07d8\u07da\u0005\u00f7\u0000\u0000"+ + "\u07d9\u07ca\u0001\u0000\u0000\u0000\u07d9\u07cb\u0001\u0000\u0000\u0000"+ + "\u07d9\u07cc\u0001\u0000\u0000\u0000\u07d9\u07d0\u0001\u0000\u0000\u0000"+ + "\u07d9\u07d6\u0001\u0000\u0000\u0000\u07d9\u07d7\u0001\u0000\u0000\u0000"+ + "\u07d9\u07d8\u0001\u0000\u0000\u0000\u07daE\u0001\u0000\u0000\u0000\u07db"+ + "\u07df\u0003\u054e\u02a7\u0000\u07dc\u07df\u00057\u0000\u0000\u07dd\u07df"+ + "\u0001\u0000\u0000\u0000\u07de\u07db\u0001\u0000\u0000\u0000\u07de\u07dc"+ + "\u0001\u0000\u0000\u0000\u07de\u07dd\u0001\u0000\u0000\u0000\u07dfG\u0001"+ + "\u0000\u0000\u0000\u07e0\u07e3\u0003\u0562\u02b1\u0000\u07e1\u07e3\u0003"+ + "\u054e\u02a7\u0000\u07e2\u07e0\u0001\u0000\u0000\u0000\u07e2\u07e1\u0001"+ + "\u0000\u0000\u0000\u07e3I\u0001\u0000\u0000\u0000\u07e4\u07e5\u0005\u0134"+ + "\u0000\u0000\u07e5\u07e6\u0003L&\u0000\u07e6K\u0001\u0000\u0000\u0000"+ + "\u07e7\u07f0\u0003N\'\u0000\u07e8\u07e9\u0005\u019d\u0000\u0000\u07e9"+ + "\u07f0\u0005\u017d\u0000\u0000\u07ea\u07eb\u0005\u015f\u0000\u0000\u07eb"+ + "\u07ec\u0005\u00ed\u0000\u0000\u07ec\u07f0\u0005\u00f4\u0000\u0000\u07ed"+ + "\u07ee\u0005\u0147\u0000\u0000\u07ee\u07f0\u0005l\u0000\u0000\u07ef\u07e7"+ + "\u0001\u0000\u0000\u0000\u07ef\u07e8\u0001\u0000\u0000\u0000\u07ef\u07ea"+ + "\u0001\u0000\u0000\u0000\u07ef\u07ed\u0001\u0000\u0000\u0000\u07f0M\u0001"+ + "\u0000\u0000\u0000\u07f1\u07f4\u0003:\u001d\u0000\u07f2\u07f4\u0005 \u0000"+ + "\u0000\u07f3\u07f1\u0001\u0000\u0000\u0000\u07f3\u07f2\u0001\u0000\u0000"+ + "\u0000\u07f4O\u0001\u0000\u0000\u0000\u07f5\u07f6\u0005\u0148\u0000\u0000"+ + "\u07f6\u07f9\u00034\u001a\u0000\u07f7\u07f9\u0003J%\u0000\u07f8\u07f5"+ + "\u0001\u0000\u0000\u0000\u07f8\u07f7\u0001\u0000\u0000\u0000\u07f9Q\u0001"+ + "\u0000\u0000\u0000\u07fa\u07fb\u0005\u0148\u0000\u0000\u07fb\u07fe\u0003"+ + "8\u001c\u0000\u07fc\u07fe\u0003J%\u0000\u07fd\u07fa\u0001\u0000\u0000"+ + "\u0000\u07fd\u07fc\u0001\u0000\u0000\u0000\u07feS\u0001\u0000\u0000\u0000"+ + "\u07ff\u0809\u0005\u014a\u0000\u0000\u0800\u080a\u0003:\u001d\u0000\u0801"+ + "\u0802\u0005\u019d\u0000\u0000\u0802\u080a\u0005\u017d\u0000\u0000\u0803"+ + "\u0804\u0005\u015f\u0000\u0000\u0804\u0805\u0005\u00ed\u0000\u0000\u0805"+ + "\u080a\u0005\u00f4\u0000\u0000\u0806\u0807\u0005\u0147\u0000\u0000\u0807"+ + "\u080a\u0005l\u0000\u0000\u0808\u080a\u0005 \u0000\u0000\u0809\u0800\u0001"+ + "\u0000\u0000\u0000\u0809\u0801\u0001\u0000\u0000\u0000\u0809\u0803\u0001"+ + "\u0000\u0000\u0000\u0809\u0806\u0001\u0000\u0000\u0000\u0809\u0808\u0001"+ + "\u0000\u0000\u0000\u080aU\u0001\u0000\u0000\u0000\u080b\u080c\u0005\u0148"+ + "\u0000\u0000\u080c\u080d\u0005\u00a7\u0000\u0000\u080d\u080e\u0003X,\u0000"+ + "\u080e\u080f\u0003Z-\u0000\u080fW\u0001\u0000\u0000\u0000\u0810\u0813"+ + "\u0005 \u0000\u0000\u0811\u0813\u0003\u0536\u029b\u0000\u0812\u0810\u0001"+ + "\u0000\u0000\u0000\u0812\u0811\u0001\u0000\u0000\u0000\u0813Y\u0001\u0000"+ + "\u0000\u0000\u0814\u0815\u0007\b\u0000\u0000\u0815[\u0001\u0000\u0000"+ + "\u0000\u0816\u0817\u0005\u009d\u0000\u0000\u0817]\u0001\u0000\u0000\u0000"+ + "\u0818\u0819\u0005\u00bd\u0000\u0000\u0819\u081a\u0007\t\u0000\u0000\u081a"+ + "_\u0001\u0000\u0000\u0000\u081b\u081c\u0005\u008c\u0000\u0000\u081c\u081f"+ + "\u0005^\u0000\u0000\u081d\u081e\u0005\u00de\u0000\u0000\u081e\u0820\u0005"+ + "\u0187\u0000\u0000\u081f\u081d\u0001\u0000\u0000\u0000\u081f\u0820\u0001"+ + "\u0000\u0000\u0000\u0820\u0821\u0001\u0000\u0000\u0000\u0821\u0824\u0003"+ + "\u0434\u021a\u0000\u0822\u0825\u0003b1\u0000\u0823\u0825\u0003d2\u0000"+ + "\u0824\u0822\u0001\u0000\u0000\u0000\u0824\u0823\u0001\u0000\u0000\u0000"+ + "\u0825\u0889\u0001\u0000\u0000\u0000\u0826\u0827\u0005\u008c\u0000\u0000"+ + "\u0827\u0828\u0005^\u0000\u0000\u0828\u0829\u0005 \u0000\u0000\u0829\u082a"+ + "\u0005F\u0000\u0000\u082a\u082b\u0005\u015a\u0000\u0000\u082b\u082f\u0003"+ + "\u053c\u029e\u0000\u082c\u082d\u0005\u0114\u0000\u0000\u082d\u082e\u0005"+ + "\u0095\u0000\u0000\u082e\u0830\u0003\u055a\u02ad\u0000\u082f\u082c\u0001"+ + "\u0000\u0000\u0000\u082f\u0830\u0001\u0000\u0000\u0000\u0830\u0831\u0001"+ + "\u0000\u0000\u0000\u0831\u0832\u0005\u0148\u0000\u0000\u0832\u0833\u0005"+ + "\u015a\u0000\u0000\u0833\u0834\u0003\u053c\u029e\u0000\u0834\u0835\u0003"+ + "\u03aa\u01d5\u0000\u0835\u0889\u0001\u0000\u0000\u0000\u0836\u0837\u0005"+ + "\u008c\u0000\u0000\u0837\u083a\u0005\u00e4\u0000\u0000\u0838\u0839\u0005"+ + "\u00de\u0000\u0000\u0839\u083b\u0005\u0187\u0000\u0000\u083a\u0838\u0001"+ + "\u0000\u0000\u0000\u083a\u083b\u0001\u0000\u0000\u0000\u083b\u083c\u0001"+ + "\u0000\u0000\u0000\u083c\u083f\u0003\u0538\u029c\u0000\u083d\u0840\u0003"+ + "b1\u0000\u083e\u0840\u0003f3\u0000\u083f\u083d\u0001\u0000\u0000\u0000"+ + "\u083f\u083e\u0001\u0000\u0000\u0000\u0840\u0889\u0001\u0000\u0000\u0000"+ + "\u0841\u0842\u0005\u008c\u0000\u0000\u0842\u0843\u0005\u00e4\u0000\u0000"+ + "\u0843\u0844\u0005 \u0000\u0000\u0844\u0845\u0005F\u0000\u0000\u0845\u0846"+ + "\u0005\u015a\u0000\u0000\u0846\u084a\u0003\u053c\u029e\u0000\u0847\u0848"+ + "\u0005\u0114\u0000\u0000\u0848\u0849\u0005\u0095\u0000\u0000\u0849\u084b"+ + "\u0003\u055a\u02ad\u0000\u084a\u0847\u0001\u0000\u0000\u0000\u084a\u084b"+ "\u0001\u0000\u0000\u0000\u084b\u084c\u0001\u0000\u0000\u0000\u084c\u084d"+ - "\u0001\u0000\u0000\u0000\u084d\u084e\u0005\u0301\u0000\u0000\u084e\u08b7"+ - "\u0001\u0000\u0000\u0000\u084f\u0850\u0005~\u0000\u0000\u0850\u0851\u0005"+ - "\u000e\u0000\u0000\u0851\u0852\u0003\u01d8\u00ec\u0000\u0852\u0853\u0005"+ - "\u0300\u0000\u0000\u0853\u0854\u0005\u02b3\u0000\u0000\u0854\u0855\u0005"+ - "\u0319\u0000\u0000\u0855\u0856\u0003\u01e4\u00f2\u0000\u0856\u0857\u0005"+ - "\u02fa\u0000\u0000\u0857\u0858\u0005\u029d\u0000\u0000\u0858\u0859\u0005"+ - "\u0319\u0000\u0000\u0859\u085a\u0003\u0210\u0108\u0000\u085a\u085b\u0005"+ - "\u02fa\u0000\u0000\u085b\u085c\u0005\u029e\u0000\u0000\u085c\u085d\u0005"+ - "\u0319\u0000\u0000\u085d\u0862\u0003\u0210\u0108\u0000\u085e\u085f\u0005"+ - "\u02fa\u0000\u0000\u085f\u0860\u0005\u029f\u0000\u0000\u0860\u0861\u0005"+ - "\u0319\u0000\u0000\u0861\u0863\u0005\u0307\u0000\u0000\u0862\u085e\u0001"+ - "\u0000\u0000\u0000\u0862\u0863\u0001\u0000\u0000\u0000\u0863\u0868\u0001"+ - "\u0000\u0000\u0000\u0864\u0865\u0005\u02fa\u0000\u0000\u0865\u0866\u0005"+ - "\u02a0\u0000\u0000\u0866\u0867\u0005\u0319\u0000\u0000\u0867\u0869\u0003"+ - "\u0210\u0108\u0000\u0868\u0864\u0001\u0000\u0000\u0000\u0868\u0869\u0001"+ - "\u0000\u0000\u0000\u0869\u086c\u0001\u0000\u0000\u0000\u086a\u086b\u0005"+ - "\u02fa\u0000\u0000\u086b\u086d\u0005\u02a1\u0000\u0000\u086c\u086a\u0001"+ - "\u0000\u0000\u0000\u086c\u086d\u0001\u0000\u0000\u0000\u086d\u0872\u0001"+ - "\u0000\u0000\u0000\u086e\u086f\u0005\u02fa\u0000\u0000\u086f\u0870\u0005"+ - "\u02a2\u0000\u0000\u0870\u0871\u0005\u0319\u0000\u0000\u0871\u0873\u0003"+ - "\u0210\u0108\u0000\u0872\u086e\u0001\u0000\u0000\u0000\u0872\u0873\u0001"+ - "\u0000\u0000\u0000\u0873\u0878\u0001\u0000\u0000\u0000\u0874\u0875\u0005"+ - "\u02fa\u0000\u0000\u0875\u0876\u0005\u02a3\u0000\u0000\u0876\u0877\u0005"+ - "\u0319\u0000\u0000\u0877\u0879\u0003\u0210\u0108\u0000\u0878\u0874\u0001"+ - "\u0000\u0000\u0000\u0878\u0879\u0001\u0000\u0000\u0000\u0879\u087e\u0001"+ - "\u0000\u0000\u0000\u087a\u087b\u0005\u02fa\u0000\u0000\u087b\u087c\u0005"+ - "\u02a4\u0000\u0000\u087c\u087d\u0005\u0319\u0000\u0000\u087d\u087f\u0003"+ - "\u0210\u0108\u0000\u087e\u087a\u0001\u0000\u0000\u0000\u087e\u087f\u0001"+ - "\u0000\u0000\u0000\u087f\u0884\u0001\u0000\u0000\u0000\u0880\u0881\u0005"+ - "\u02fa\u0000\u0000\u0881\u0882\u0005\u02a5\u0000\u0000\u0882\u0883\u0005"+ - "\u0319\u0000\u0000\u0883\u0885\u0003\u01b8\u00dc\u0000\u0884\u0880\u0001"+ - "\u0000\u0000\u0000\u0884\u0885\u0001\u0000\u0000\u0000\u0885\u088a\u0001"+ - "\u0000\u0000\u0000\u0886\u0887\u0005\u02fa\u0000\u0000\u0887\u0888\u0005"+ - "\u02a6\u0000\u0000\u0888\u0889\u0005\u0319\u0000\u0000\u0889\u088b\u0003"+ - "\u0210\u0108\u0000\u088a\u0886\u0001\u0000\u0000\u0000\u088a\u088b\u0001"+ - "\u0000\u0000\u0000\u088b\u0890\u0001\u0000\u0000\u0000\u088c\u088d\u0005"+ - "\u02fa\u0000\u0000\u088d\u088e\u0005\u02a7\u0000\u0000\u088e\u088f\u0005"+ - "\u0319\u0000\u0000\u088f\u0891\u0003\u0210\u0108\u0000\u0890\u088c\u0001"+ - "\u0000\u0000\u0000\u0890\u0891\u0001\u0000\u0000\u0000\u0891\u0896\u0001"+ - "\u0000\u0000\u0000\u0892\u0893\u0005\u02fa\u0000\u0000\u0893\u0894\u0005"+ - "\u02a8\u0000\u0000\u0894\u0895\u0005\u0319\u0000\u0000\u0895\u0897\u0003"+ - "\u0210\u0108\u0000\u0896\u0892\u0001\u0000\u0000\u0000\u0896\u0897\u0001"+ - "\u0000\u0000\u0000\u0897\u089c\u0001\u0000\u0000\u0000\u0898\u0899\u0005"+ - "\u02fa\u0000\u0000\u0899\u089a\u0005\u02a9\u0000\u0000\u089a\u089b\u0005"+ - "\u0319\u0000\u0000\u089b\u089d\u0005\u0307\u0000\u0000\u089c\u0898\u0001"+ - "\u0000\u0000\u0000\u089c\u089d\u0001\u0000\u0000\u0000\u089d\u08a2\u0001"+ - "\u0000\u0000\u0000\u089e\u089f\u0005\u02fa\u0000\u0000\u089f\u08a0\u0005"+ - "\u02aa\u0000\u0000\u08a0\u08a1\u0005\u0319\u0000\u0000\u08a1\u08a3\u0003"+ - "\u0210\u0108\u0000\u08a2\u089e\u0001\u0000\u0000\u0000\u08a2\u08a3\u0001"+ - "\u0000\u0000\u0000\u08a3\u08a6\u0001\u0000\u0000\u0000\u08a4\u08a5\u0005"+ - "\u02fa\u0000\u0000\u08a5\u08a7\u0005\u02ab\u0000\u0000\u08a6\u08a4\u0001"+ - "\u0000\u0000\u0000\u08a6\u08a7\u0001\u0000\u0000\u0000\u08a7\u08ac\u0001"+ - "\u0000\u0000\u0000\u08a8\u08a9\u0005\u02fa\u0000\u0000\u08a9\u08aa\u0005"+ - "\u02ac\u0000\u0000\u08aa\u08ab\u0005\u0319\u0000\u0000\u08ab\u08ad\u0003"+ - "\u0210\u0108\u0000\u08ac\u08a8\u0001\u0000\u0000\u0000\u08ac\u08ad\u0001"+ - "\u0000\u0000\u0000\u08ad\u08b2\u0001\u0000\u0000\u0000\u08ae\u08af\u0005"+ - "\u02fa\u0000\u0000\u08af\u08b0\u0005\u02ad\u0000\u0000\u08b0\u08b1\u0005"+ - "\u0319\u0000\u0000\u08b1\u08b3\u0003\u0210\u0108\u0000\u08b2\u08ae\u0001"+ - "\u0000\u0000\u0000\u08b2\u08b3\u0001\u0000\u0000\u0000\u08b3\u08b4\u0001"+ - "\u0000\u0000\u0000\u08b4\u08b5\u0005\u0301\u0000\u0000\u08b5\u08b7\u0001"+ - "\u0000\u0000\u0000\u08b6\u079c\u0001\u0000\u0000\u0000\u08b6\u080e\u0001"+ - "\u0000\u0000\u0000\u08b6\u084f\u0001\u0000\u0000\u0000\u08b7s\u0001\u0000"+ - "\u0000\u0000\u08b8\u08b9\u0005~\u0000\u0000\u08b9\u08ba\u0005?\u0000\u0000"+ - "\u08ba\u08bb\u0005\u0300\u0000\u0000\u08bb\u08bc\u0003\u01e4\u00f2\u0000"+ - "\u08bc\u08bd\u0005\u001b\u0000\u0000\u08bd\u08be\u0003\u01e4\u00f2\u0000"+ - "\u08be\u08cc\u0005\u0301\u0000\u0000\u08bf\u08c0\u0005\u0288\u0000\u0000"+ - "\u08c0\u08c1\u0005\u00ee\u0000\u0000\u08c1\u08c6\u0003\u0210\u0108\u0000"+ - "\u08c2\u08c3\u0005\u0300\u0000\u0000\u08c3\u08c4\u0003\u01e6\u00f3\u0000"+ - "\u08c4\u08c5\u0005\u0301\u0000\u0000\u08c5\u08c7\u0001\u0000\u0000\u0000"+ - "\u08c6\u08c2\u0001\u0000\u0000\u0000\u08c6\u08c7\u0001\u0000\u0000\u0000"+ - "\u08c7\u08cd\u0001\u0000\u0000\u0000\u08c8\u08c9\u0005\u028a\u0000\u0000"+ - "\u08c9\u08cd\u0005\u00ee\u0000\u0000\u08ca\u08cb\u0005\u0288\u0000\u0000"+ - "\u08cb\u08cd\u0005\u0113\u0000\u0000\u08cc\u08bf\u0001\u0000\u0000\u0000"+ - "\u08cc\u08c8\u0001\u0000\u0000\u0000\u08cc\u08ca\u0001\u0000\u0000\u0000"+ - "\u08cd\u08d2\u0001\u0000\u0000\u0000\u08ce\u08cf\u0005\u001b\u0000\u0000"+ - "\u08cf\u08d3\u0005\u001f\u0000\u0000\u08d0\u08d1\u0005\u001b\u0000\u0000"+ - "\u08d1\u08d3\u0005\u0108\u0000\u0000\u08d2\u08ce\u0001\u0000\u0000\u0000"+ - "\u08d2\u08d0\u0001\u0000\u0000\u0000\u08d2\u08d3\u0001\u0000\u0000\u0000"+ - "\u08d3u\u0001\u0000\u0000\u0000\u08d4\u08d5\u0005\u02b5\u0000\u0000\u08d5"+ - "\u08d6\u0005\u0319\u0000\u0000\u08d6\u08e7\u0003\u01b8\u00dc\u0000\u08d7"+ - "\u08d8\u0005\u02b6\u0000\u0000\u08d8\u08d9\u0005\u0319\u0000\u0000\u08d9"+ - "\u08e7\u0003\u01b8\u00dc\u0000\u08da\u08db\u0005\u02b7\u0000\u0000\u08db"+ - "\u08dc\u0005\u0319\u0000\u0000\u08dc\u08e7\u0003\u01b8\u00dc\u0000\u08dd"+ - "\u08de\u0005\u02b8\u0000\u0000\u08de\u08df\u0005\u0319\u0000\u0000\u08df"+ - "\u08e7\u0003\u01b8\u00dc\u0000\u08e0\u08e1\u0005\u02b9\u0000\u0000\u08e1"+ - "\u08e2\u0005\u0319\u0000\u0000\u08e2\u08e7\u0003\u01b8\u00dc\u0000\u08e3"+ - "\u08e4\u0005\u030b\u0000\u0000\u08e4\u08e5\u0005\u0319\u0000\u0000\u08e5"+ - "\u08e7\u0003\u01b8\u00dc\u0000\u08e6\u08d4\u0001\u0000\u0000\u0000\u08e6"+ - "\u08d7\u0001\u0000\u0000\u0000\u08e6\u08da\u0001\u0000\u0000\u0000\u08e6"+ - "\u08dd\u0001\u0000\u0000\u0000\u08e6\u08e0\u0001\u0000\u0000\u0000\u08e6"+ - "\u08e3\u0001\u0000\u0000\u0000\u08e7w\u0001\u0000\u0000\u0000\u08e8\u08ed"+ - "\u0003v;\u0000\u08e9\u08ea\u0005\u02fa\u0000\u0000\u08ea\u08ec\u0003v"+ - ";\u0000\u08eb\u08e9\u0001\u0000\u0000\u0000\u08ec\u08ef\u0001\u0000\u0000"+ - "\u0000\u08ed\u08eb\u0001\u0000\u0000\u0000\u08ed\u08ee\u0001\u0000\u0000"+ - "\u0000\u08eey\u0001\u0000\u0000\u0000\u08ef\u08ed\u0001\u0000\u0000\u0000"+ - "\u08f0\u08f1\u0005~\u0000\u0000\u08f1\u08f5\u0005Y\u0000\u0000\u08f2\u08f3"+ - "\u0005\u02b4\u0000\u0000\u08f3\u08f4\u0005\u016d\u0000\u0000\u08f4\u08f6"+ - "\u0005\u00d3\u0000\u0000\u08f5\u08f2\u0001\u0000\u0000\u0000\u08f5\u08f6"+ - "\u0001\u0000\u0000\u0000\u08f6\u08f7\u0001\u0000\u0000\u0000\u08f7\u08f8"+ - "\u0003\u01d8\u00ec\u0000\u08f8\u08f9\u0005\u0300\u0000\u0000\u08f9\u08fa"+ - "\u0003x<\u0000\u08fa\u08fb\u0005\u0301\u0000\u0000\u08fb\u0908\u0001\u0000"+ - "\u0000\u0000\u08fc\u08fd\u0005~\u0000\u0000\u08fd\u0901\u0005Y\u0000\u0000"+ - "\u08fe\u08ff\u0005\u02b4\u0000\u0000\u08ff\u0900\u0005\u016d\u0000\u0000"+ - "\u0900\u0902\u0005\u00d3\u0000\u0000\u0901\u08fe\u0001\u0000\u0000\u0000"+ - "\u0901\u0902\u0001\u0000\u0000\u0000\u0902\u0903\u0001\u0000\u0000\u0000"+ - "\u0903\u0904\u0003\u01d8\u00ec\u0000\u0904\u0905\u0005\u00ec\u0000\u0000"+ - "\u0905\u0906\u0003\u01d8\u00ec\u0000\u0906\u0908\u0001\u0000\u0000\u0000"+ - "\u0907\u08f0\u0001\u0000\u0000\u0000\u0907\u08fc\u0001\u0000\u0000\u0000"+ - "\u0908{\u0001\u0000\u0000\u0000\u0909\u090b\u0005~\u0000\u0000\u090a\u090c"+ - "\u0005\u009b\u0000\u0000\u090b\u090a\u0001\u0000\u0000\u0000\u090b\u090c"+ - "\u0001\u0000\u0000\u0000\u090c\u090d\u0001\u0000\u0000\u0000\u090d\u090e"+ - "\u0005u\u0000\u0000\u090e\u090f\u0003\u0210\u0108\u0000\u090f\u0910\u0005"+ - "\u00e3\u0000\u0000\u0910\u0911\u0005\u030a\u0000\u0000\u0911\u0912\u0005"+ - "\u0247\u0000\u0000\u0912\u0913\u0005\u030a\u0000\u0000\u0913\u0914\u0005"+ - "\u00ec\u0000\u0000\u0914\u0915\u0003\u01d8\u00ec\u0000\u0915}\u0001\u0000"+ - "\u0000\u0000\u0916\u0917\u0005~\u0000\u0000\u0917\u0918\u0005\u0092\u0000"+ - "\u0000\u0918\u091a\u0003\u01d8\u00ec\u0000\u0919\u091b\u0005\u0288\u0000"+ - "\u0000\u091a\u0919\u0001\u0000\u0000\u0000\u091a\u091b\u0001\u0000\u0000"+ - "\u0000\u091b\u091f\u0001\u0000\u0000\u0000\u091c\u091d\u0005\u0193\u0000"+ - "\u0000\u091d\u091e\u0005\u0319\u0000\u0000\u091e\u0920\u0003\u01d8\u00ec"+ - "\u0000\u091f\u091c\u0001\u0000\u0000\u0000\u091f\u0920\u0001\u0000\u0000"+ - "\u0000\u0920\u0924\u0001\u0000\u0000\u0000\u0921\u0922\u0005\u023c\u0000"+ - "\u0000\u0922\u0923\u0005\u0319\u0000\u0000\u0923\u0925\u0003\u01d8\u00ec"+ - "\u0000\u0924\u0921\u0001\u0000\u0000\u0000\u0924\u0925\u0001\u0000\u0000"+ - "\u0000\u0925\u0929\u0001\u0000\u0000\u0000\u0926\u0927\u0005\u00c4\u0000"+ - "\u0000\u0927\u0928\u0005\u0319\u0000\u0000\u0928\u092a\u0003\u01d8\u00ec"+ - "\u0000\u0929\u0926\u0001\u0000\u0000\u0000\u0929\u092a\u0001\u0000\u0000"+ - "\u0000\u092a\u092e\u0001\u0000\u0000\u0000\u092b\u092c\u0005\u02b6\u0000"+ - "\u0000\u092c\u092d\u0005\u0319\u0000\u0000\u092d\u092f\u0003\u01d8\u00ec"+ - "\u0000\u092e\u092b\u0001\u0000\u0000\u0000\u092e\u092f\u0001\u0000\u0000"+ - "\u0000\u092f\u0933\u0001\u0000\u0000\u0000\u0930\u0931\u0005\u02b7\u0000"+ - "\u0000\u0931\u0932\u0005\u0319\u0000\u0000\u0932\u0934\u0003\u01d8\u00ec"+ - "\u0000\u0933\u0930\u0001\u0000\u0000\u0000\u0933\u0934\u0001\u0000\u0000"+ - "\u0000\u0934\u0938\u0001\u0000\u0000\u0000\u0935\u0936\u0005\u023a\u0000"+ - "\u0000\u0936\u0937\u0005\u0319\u0000\u0000\u0937\u0939\u0003\u01d8\u00ec"+ - "\u0000\u0938\u0935\u0001\u0000\u0000\u0000\u0938\u0939\u0001\u0000\u0000"+ - "\u0000\u0939\u093d\u0001\u0000\u0000\u0000\u093a\u093b\u0005\u02ba\u0000"+ - "\u0000\u093b\u093c\u0005\u0319\u0000\u0000\u093c\u093e\u0003\u01d8\u00ec"+ - "\u0000\u093d\u093a\u0001\u0000\u0000\u0000\u093d\u093e\u0001\u0000\u0000"+ - "\u0000\u093e\u0943\u0001\u0000\u0000\u0000\u093f\u0940\u0005k\u0000\u0000"+ - "\u0940\u0941\u0005\u0136\u0000\u0000\u0941\u0942\u0005\u0319\u0000\u0000"+ - "\u0942\u0944\u0003\u01bc\u00de\u0000\u0943\u093f\u0001\u0000\u0000\u0000"+ - "\u0943\u0944\u0001\u0000\u0000\u0000\u0944\u0948\u0001\u0000\u0000\u0000"+ - "\u0945\u0946\u0005\u02bb\u0000\u0000\u0946\u0947\u0005\u0319\u0000\u0000"+ - "\u0947\u0949\u0003\u01bc\u00de\u0000\u0948\u0945\u0001\u0000\u0000\u0000"+ - "\u0948\u0949\u0001\u0000\u0000\u0000\u0949\u007f\u0001\u0000\u0000\u0000"+ - "\u094a\u094b\u0005m\u0000\u0000\u094b\u094d\u0003\u01d8\u00ec\u0000\u094c"+ - "\u094a\u0001\u0000\u0000\u0000\u094c\u094d\u0001\u0000\u0000\u0000\u094d"+ - "\u0956\u0001\u0000\u0000\u0000\u094e\u094f\u0005\u016d\u0000\u0000\u094f"+ - "\u0957\u0005\u0172\u0000\u0000\u0950\u0957\u0005\u0172\u0000\u0000\u0951"+ - "\u0952\u0005N\u0000\u0000\u0952\u0953\u0005\u0300\u0000\u0000\u0953\u0954"+ - "\u0003\u01b8\u00dc\u0000\u0954\u0955\u0005\u0301\u0000\u0000\u0955\u0957"+ - "\u0001\u0000\u0000\u0000\u0956\u094e\u0001\u0000\u0000\u0000\u0956\u0950"+ - "\u0001\u0000\u0000\u0000\u0956\u0951\u0001\u0000\u0000\u0000\u0957\u0081"+ - "\u0001\u0000\u0000\u0000\u0958\u0959\u0005~\u0000\u0000\u0959\u095a\u0005"+ - "\u00ba\u0000\u0000\u095a\u095c\u0003\u01d8\u00ec\u0000\u095b\u095d\u0005"+ - "\u001b\u0000\u0000\u095c\u095b\u0001\u0000\u0000\u0000\u095c\u095d\u0001"+ - "\u0000\u0000\u0000\u095d\u095e\u0001\u0000\u0000\u0000\u095e\u0966\u0003"+ - "\u01e4\u00f2\u0000\u095f\u0960\u0005X\u0000\u0000\u0960\u0965\u0003\u01d8"+ - "\u00ec\u0000\u0961\u0962\u0005\u009b\u0000\u0000\u0962\u0965\u0003\u01b8"+ - "\u00dc\u0000\u0963\u0965\u0003\u0080@\u0000\u0964\u095f\u0001\u0000\u0000"+ - "\u0000\u0964\u0961\u0001\u0000\u0000\u0000\u0964\u0963\u0001\u0000\u0000"+ - "\u0000\u0965\u0968\u0001\u0000\u0000\u0000\u0966\u0964\u0001\u0000\u0000"+ - "\u0000\u0966\u0967\u0001\u0000\u0000\u0000\u0967\u0083\u0001\u0000\u0000"+ - "\u0000\u0968\u0966\u0001\u0000\u0000\u0000\u0969\u096a\u0003\u0210\u0108"+ - "\u0000\u096a\u096b\u0005\u0109\u0000\u0000\u096b\u096c\u0005\u0300\u0000"+ - "\u0000\u096c\u0971\u0005\u030a\u0000\u0000\u096d\u096e\u0005\u02fa\u0000"+ - "\u0000\u096e\u0970\u0005\u030a\u0000\u0000\u096f\u096d\u0001\u0000\u0000"+ - "\u0000\u0970\u0973\u0001\u0000\u0000\u0000\u0971\u096f\u0001\u0000\u0000"+ - "\u0000\u0971\u0972\u0001\u0000\u0000\u0000\u0972\u0974\u0001\u0000\u0000"+ - "\u0000\u0973\u0971\u0001\u0000\u0000\u0000\u0974\u0979\u0005\u0301\u0000"+ - "\u0000\u0975\u0976\u0005\u0017\u0000\u0000\u0976\u0978\u0003\u0084B\u0000"+ - "\u0977\u0975\u0001\u0000\u0000\u0000\u0978\u097b\u0001\u0000\u0000\u0000"+ - "\u0979\u0977\u0001\u0000\u0000\u0000\u0979\u097a\u0001\u0000\u0000\u0000"+ - "\u097a\u0085\u0001\u0000\u0000\u0000\u097b\u0979\u0001\u0000\u0000\u0000"+ - "\u097c\u097d\u0005~\u0000\u0000\u097d\u097e\u0005\u02bc\u0000\u0000\u097e"+ - "\u097f\u0005\u0255\u0000\u0000\u097f\u0980\u0003\u0210\u0108\u0000\u0980"+ - "\u0981\u0005\u0180\u0000\u0000\u0981\u0984\u0003\u0210\u0108\u0000\u0982"+ - "\u0983\u0005\u0283\u0000\u0000\u0983\u0985\u0003\u0084B\u0000\u0984\u0982"+ - "\u0001\u0000\u0000\u0000\u0984\u0985\u0001\u0000\u0000\u0000\u0985\u0986"+ - "\u0001\u0000\u0000\u0000\u0986\u0987\u0005\u00d1\u0000\u0000\u0987\u0988"+ - "\u0005\u01b8\u0000\u0000\u0988\u0989\u0003\u0210\u0108\u0000\u0989\u098a"+ - "\u0005\u0300\u0000\u0000\u098a\u098b\u0005\u0301\u0000\u0000\u098b\u0087"+ - "\u0001\u0000\u0000\u0000\u098c\u098d\u0003\u01d8\u00ec\u0000\u098d\u0992"+ - "\u0005\u030a\u0000\u0000\u098e\u098f\u0005\u02fa\u0000\u0000\u098f\u0991"+ - "\u0003\u0088D\u0000\u0990\u098e\u0001\u0000\u0000\u0000\u0991\u0994\u0001"+ - "\u0000\u0000\u0000\u0992\u0990\u0001\u0000\u0000\u0000\u0992\u0993\u0001"+ - "\u0000\u0000\u0000\u0993\u0089\u0001\u0000\u0000\u0000\u0994\u0992\u0001"+ - "\u0000\u0000\u0000\u0995\u0996\u0005~\u0000\u0000\u0996\u0997\u0005\u00e5"+ - "\u0000\u0000\u0997\u0998\u0005\u0091\u0000\u0000\u0998\u0999\u0005\u02bd"+ - "\u0000\u0000\u0999\u09a0\u0003\u0210\u0108\u0000\u099a\u099b\u0005\u00fc"+ - "\u0000\u0000\u099b\u099f\u0003\u0210\u0108\u0000\u099c\u099d\u0005\u0167"+ - "\u0000\u0000\u099d\u099f\u0005\u00fc\u0000\u0000\u099e\u099a\u0001\u0000"+ - "\u0000\u0000\u099e\u099c\u0001\u0000\u0000\u0000\u099f\u09a2\u0001\u0000"+ - "\u0000\u0000\u09a0\u099e\u0001\u0000\u0000\u0000\u09a0\u09a1\u0001\u0000"+ - "\u0000\u0000\u09a1\u09a7\u0001\u0000\u0000\u0000\u09a2\u09a0\u0001\u0000"+ - "\u0000\u0000\u09a3\u09a4\u0005\u0277\u0000\u0000\u09a4\u09a8\u0003\u0210"+ - "\u0108\u0000\u09a5\u09a6\u0005\u0167\u0000\u0000\u09a6\u09a8\u0005\u0277"+ - "\u0000\u0000\u09a7\u09a3\u0001\u0000\u0000\u0000\u09a7\u09a5\u0001\u0000"+ - "\u0000\u0000\u09a7\u09a8\u0001\u0000\u0000\u0000\u09a8\u09ae\u0001\u0000"+ - "\u0000\u0000\u09a9\u09aa\u0005\u0186\u0000\u0000\u09aa\u09ab\u0005\u0300"+ - "\u0000\u0000\u09ab\u09ac\u0003\u0088D\u0000\u09ac\u09ad\u0005\u0301\u0000"+ - "\u0000\u09ad\u09af\u0001\u0000\u0000\u0000\u09ae\u09a9\u0001\u0000\u0000"+ - "\u0000\u09ae\u09af\u0001\u0000\u0000\u0000\u09af\u008b\u0001\u0000\u0000"+ - "\u0000\u09b0\u09b1\u0005~\u0000\u0000\u09b1\u09b2\u0005\u00e5\u0000\u0000"+ - "\u09b2\u09b6\u0005\u0237\u0000\u0000\u09b3\u09b4\u0005\u02b4\u0000\u0000"+ - "\u09b4\u09b5\u0005\u016d\u0000\u0000\u09b5\u09b7\u0005\u00d3\u0000\u0000"+ - "\u09b6\u09b3\u0001\u0000\u0000\u0000\u09b6\u09b7\u0001\u0000\u0000\u0000"+ - "\u09b7\u09b8\u0001\u0000\u0000\u0000\u09b8\u09b9\u0003\u0210\u0108\u0000"+ - "\u09b9\u09ba\u0005\u0300\u0000\u0000\u09ba\u09bb\u0003\u0210\u0108\u0000"+ - "\u09bb\u09c1\u0003\u0210\u0108\u0000\u09bc\u09bd\u0005\u0186\u0000\u0000"+ - "\u09bd\u09be\u0005\u0300\u0000\u0000\u09be\u09bf\u0003\u0088D\u0000\u09bf"+ - "\u09c0\u0005\u0301\u0000\u0000\u09c0\u09c2\u0001\u0000\u0000\u0000\u09c1"+ - "\u09bc\u0001\u0000\u0000\u0000\u09c1\u09c2\u0001\u0000\u0000\u0000\u09c2"+ - "\u09c5\u0001\u0000\u0000\u0000\u09c3\u09c4\u0005X\u0000\u0000\u09c4\u09c6"+ - "\u0003v;\u0000\u09c5\u09c3\u0001\u0000\u0000\u0000\u09c5\u09c6\u0001\u0000"+ - "\u0000\u0000\u09c6\u09c7\u0001\u0000\u0000\u0000\u09c7\u09ca\u0005\u0301"+ - "\u0000\u0000\u09c8\u09c9\u0005\u010f\u0000\u0000\u09c9\u09cb\u0003\u01da"+ - "\u00ed\u0000\u09ca\u09c8\u0001\u0000\u0000\u0000\u09ca\u09cb\u0001\u0000"+ - "\u0000\u0000\u09cb\u09cc\u0001\u0000\u0000\u0000\u09cc\u09cd\u0005\u02be"+ - "\u0000\u0000\u09cd\u09d3\u0003\u01d8\u00ec\u0000\u09ce\u09cf\u0005\u0186"+ - "\u0000\u0000\u09cf\u09d0\u0005\u0300\u0000\u0000\u09d0\u09d1\u0003\u0088"+ - "D\u0000\u09d1\u09d2\u0005\u0301\u0000\u0000\u09d2\u09d4\u0001\u0000\u0000"+ - "\u0000\u09d3\u09ce\u0001\u0000\u0000\u0000\u09d3\u09d4\u0001\u0000\u0000"+ - "\u0000\u09d4\u008d\u0001\u0000\u0000\u0000\u09d5\u09d8\u0005~\u0000\u0000"+ - "\u09d6\u09d7\u0005\u0187\u0000\u0000\u09d7\u09d9\u0005\u01d6\u0000\u0000"+ - "\u09d8\u09d6\u0001\u0000\u0000\u0000\u09d8\u09d9\u0001\u0000\u0000\u0000"+ - "\u09d9\u09da\u0001\u0000\u0000\u0000\u09da\u09db\u0005\u00ee\u0000\u0000"+ - "\u09db\u09dc\u0003\u01d8\u00ec\u0000\u09dc\u008f\u0001\u0000\u0000\u0000"+ - "\u09dd\u09de\u0005~\u0000\u0000\u09de\u09df\u0005\u00fa\u0000\u0000\u09df"+ - "\u0a09\u0003\u0210\u0108\u0000\u09e0\u09e2\u0005\u0288\u0000\u0000\u09e1"+ - "\u09e0\u0001\u0000\u0000\u0000\u09e1\u09e2\u0001\u0000\u0000\u0000\u09e2"+ - "\u0a05\u0001\u0000\u0000\u0000\u09e3\u0a06\u0005\u0291\u0000\u0000\u09e4"+ - "\u0a06\u0005\u0292\u0000\u0000\u09e5\u0a06\u0005\u007f\u0000\u0000\u09e6"+ - "\u0a06\u0005\u0168\u0000\u0000\u09e7\u0a06\u0005\u0293\u0000\u0000\u09e8"+ - "\u0a06\u0005\u0294\u0000\u0000\u09e9\u0a06\u0005\u0080\u0000\u0000\u09ea"+ - "\u0a06\u0005\u0169\u0000\u0000\u09eb\u0a06\u0005\u0295\u0000\u0000\u09ec"+ - "\u0a06\u0005\u0296\u0000\u0000\u09ed\u0a06\u0005\u0297\u0000\u0000\u09ee"+ - "\u0a06\u0005\u0298\u0000\u0000\u09ef\u09f1\u0007\b\u0000\u0000\u09f0\u09ef"+ - "\u0001\u0000\u0000\u0000\u09f0\u09f1\u0001\u0000\u0000\u0000\u09f1\u09f2"+ - "\u0001\u0000\u0000\u0000\u09f2\u09f3\u0005\u01a1\u0000\u0000\u09f3\u0a06"+ - "\u0007\t\u0000\u0000\u09f4\u09f5\u0005\u0275\u0000\u0000\u09f5\u09f6\u0005"+ - "\u026a\u0000\u0000\u09f6\u0a06\u0005\u030a\u0000\u0000\u09f7\u09f8\u0005"+ - "\u0109\u0000\u0000\u09f8\u09f9\u0005\u01e5\u0000\u0000\u09f9\u0a06\u0003"+ - "\u01da\u00ed\u0000\u09fa\u09fb\u0005\u0109\u0000\u0000\u09fb\u09fc\u0005"+ - "\u00fa\u0000\u0000\u09fc\u0a06\u0003\u01da\u00ed\u0000\u09fd\u09fe\u0005"+ - "\u01e5\u0000\u0000\u09fe\u0a06\u0003\u01da\u00ed\u0000\u09ff\u0a00\u0005"+ - "\f\u0000\u0000\u0a00\u0a06\u0003\u01da\u00ed\u0000\u0a01\u0a02\u0005\u026e"+ - "\u0000\u0000\u0a02\u0a06\u0003\u01da\u00ed\u0000\u0a03\u0a04\u0005\u0234"+ - "\u0000\u0000\u0a04\u0a06\u0005\u0307\u0000\u0000\u0a05\u09e3\u0001\u0000"+ - "\u0000\u0000\u0a05\u09e4\u0001\u0000\u0000\u0000\u0a05\u09e5\u0001\u0000"+ - "\u0000\u0000\u0a05\u09e6\u0001\u0000\u0000\u0000\u0a05\u09e7\u0001\u0000"+ - "\u0000\u0000\u0a05\u09e8\u0001\u0000\u0000\u0000\u0a05\u09e9\u0001\u0000"+ - "\u0000\u0000\u0a05\u09ea\u0001\u0000\u0000\u0000\u0a05\u09eb\u0001\u0000"+ - "\u0000\u0000\u0a05\u09ec\u0001\u0000\u0000\u0000\u0a05\u09ed\u0001\u0000"+ - "\u0000\u0000\u0a05\u09ee\u0001\u0000\u0000\u0000\u0a05\u09f0\u0001\u0000"+ - "\u0000\u0000\u0a05\u09f4\u0001\u0000\u0000\u0000\u0a05\u09f7\u0001\u0000"+ - "\u0000\u0000\u0a05\u09fa\u0001\u0000\u0000\u0000\u0a05\u09fd\u0001\u0000"+ - "\u0000\u0000\u0a05\u09ff\u0001\u0000\u0000\u0000\u0a05\u0a01\u0001\u0000"+ - "\u0000\u0000\u0a05\u0a03\u0001\u0000\u0000\u0000\u0a06\u0a07\u0001\u0000"+ - "\u0000\u0000\u0a07\u0a05\u0001\u0000\u0000\u0000\u0a07\u0a08\u0001\u0000"+ - "\u0000\u0000\u0a08\u0a0a\u0001\u0000\u0000\u0000\u0a09\u09e1\u0001\u0000"+ - "\u0000\u0000\u0a09\u0a0a\u0001\u0000\u0000\u0000\u0a0a\u0091\u0001\u0000"+ - "\u0000\u0000\u0a0b\u0a0d\u0005~\u0000\u0000\u0a0c\u0a0e\u0005\u0264\u0000"+ - "\u0000\u0a0d\u0a0c\u0001\u0000\u0000\u0000\u0a0d\u0a0e\u0001\u0000\u0000"+ - "\u0000\u0a0e\u0a0f\u0001\u0000\u0000\u0000\u0a0f\u0a11\u0005\u010c\u0000"+ - "\u0000\u0a10\u0a12\u0005\u02c5\u0000\u0000\u0a11\u0a10\u0001\u0000\u0000"+ - "\u0000\u0a11\u0a12\u0001\u0000\u0000\u0000\u0a12\u0a19\u0001\u0000\u0000"+ - "\u0000\u0a13\u0a14\u0005\u02b4\u0000\u0000\u0a14\u0a15\u0005\u016d\u0000"+ - "\u0000\u0a15\u0a17\u0005\u00d3\u0000\u0000\u0a16\u0a13\u0001\u0000\u0000"+ - "\u0000\u0a16\u0a17\u0001\u0000\u0000\u0000\u0a17\u0a18\u0001\u0000\u0000"+ - "\u0000\u0a18\u0a1a\u0003\u0210\u0108\u0000\u0a19\u0a16\u0001\u0000\u0000"+ - "\u0000\u0a19\u0a1a\u0001\u0000\u0000\u0000\u0a1a\u0a1b\u0001\u0000\u0000"+ - "\u0000\u0a1b\u0a1c\u0005\u0180\u0000\u0000\u0a1c\u0a1f\u0003\u0210\u0108"+ - "\u0000\u0a1d\u0a1e\u0005\u0273\u0000\u0000\u0a1e\u0a20\u0003\u01e8\u00f4"+ - "\u0000\u0a1f\u0a1d\u0001\u0000\u0000\u0000\u0a1f\u0a20\u0001\u0000\u0000"+ - "\u0000\u0a20\u0a23\u0001\u0000\u0000\u0000\u0a21\u0a22\u0005\u023a\u0000"+ - "\u0000\u0a22\u0a24\u0003\u0210\u0108\u0000\u0a23\u0a21\u0001\u0000\u0000"+ - "\u0000\u0a23\u0a24\u0001\u0000\u0000\u0000\u0a24\u0a27\u0001\u0000\u0000"+ - "\u0000\u0a25\u0a26\u0005\u0285\u0000\u0000\u0a26\u0a28\u0003\u01f8\u00fc"+ - "\u0000\u0a27\u0a25\u0001\u0000\u0000\u0000\u0a27\u0a28\u0001\u0000\u0000"+ - "\u0000\u0a28\u0093\u0001\u0000\u0000\u0000\u0a29\u0a2c\u0005~\u0000\u0000"+ - "\u0a2a\u0a2b\u0005\u0187\u0000\u0000\u0a2b\u0a2d\u0005\u01d6\u0000\u0000"+ - "\u0a2c\u0a2a\u0001\u0000\u0000\u0000\u0a2c\u0a2d\u0001\u0000\u0000\u0000"+ - "\u0a2d\u0a2f\u0001\u0000\u0000\u0000\u0a2e\u0a30\u0005\u01b7\u0000\u0000"+ - "\u0a2f\u0a2e\u0001\u0000\u0000\u0000\u0a2f\u0a30\u0001\u0000\u0000\u0000"+ - "\u0a30\u0a31\u0001\u0000\u0000\u0000\u0a31\u0a32\u0005\u012b\u0000\u0000"+ - "\u0a32\u0a4b\u0003\u0210\u0108\u0000\u0a33\u0a36\u0005~\u0000\u0000\u0a34"+ - "\u0a35\u0005\u0187\u0000\u0000\u0a35\u0a37\u0005\u01d6\u0000\u0000\u0a36"+ - "\u0a34\u0001\u0000\u0000\u0000\u0a36\u0a37\u0001\u0000\u0000\u0000\u0a37"+ - "\u0a39\u0001\u0000\u0000\u0000\u0a38\u0a3a\u0005\u025c\u0000\u0000\u0a39"+ - "\u0a38\u0001\u0000\u0000\u0000\u0a39\u0a3a\u0001\u0000\u0000\u0000\u0a3a"+ - "\u0a3c\u0001\u0000\u0000\u0000\u0a3b\u0a3d\u0005\u01b7\u0000\u0000\u0a3c"+ - "\u0a3b\u0001\u0000\u0000\u0000\u0a3c\u0a3d\u0001\u0000\u0000\u0000\u0a3d"+ - "\u0a3e\u0001\u0000\u0000\u0000\u0a3e\u0a3f\u0005\u012b\u0000\u0000\u0a3f"+ - "\u0a40\u0003\u0210\u0108\u0000\u0a40\u0a41\u0005\u00fc\u0000\u0000\u0a41"+ - "\u0a44\u0003\u0210\u0108\u0000\u0a42\u0a43\u0005\u02c6\u0000\u0000\u0a43"+ - "\u0a45\u0003\u0210\u0108\u0000\u0a44\u0a42\u0001\u0000\u0000\u0000\u0a44"+ - "\u0a45\u0001\u0000\u0000\u0000\u0a45\u0a48\u0001\u0000\u0000\u0000\u0a46"+ - "\u0a47\u0005\u0277\u0000\u0000\u0a47\u0a49\u0003\u0210\u0108\u0000\u0a48"+ - "\u0a46\u0001\u0000\u0000\u0000\u0a48\u0a49\u0001\u0000\u0000\u0000\u0a49"+ - "\u0a4b\u0001\u0000\u0000\u0000\u0a4a\u0a29\u0001\u0000\u0000\u0000\u0a4a"+ - "\u0a33\u0001\u0000\u0000\u0000\u0a4b\u0095\u0001\u0000\u0000\u0000\u0a4c"+ - "\u0a4d\u0005~\u0000\u0000\u0a4d\u0a4e\u0005\u02c7\u0000\u0000\u0a4e\u0a52"+ - "\u0005\u0281\u0000\u0000\u0a4f\u0a50\u0005\u02b4\u0000\u0000\u0a50\u0a51"+ - "\u0005\u016d\u0000\u0000\u0a51\u0a53\u0005\u00d3\u0000\u0000\u0a52\u0a4f"+ - "\u0001\u0000\u0000\u0000\u0a52\u0a53\u0001\u0000\u0000\u0000\u0a53\u0a54"+ - "\u0001\u0000\u0000\u0000\u0a54\u0a59\u0003\u0210\u0108\u0000\u0a55\u0a56"+ - "\u0005\u0300\u0000\u0000\u0a56\u0a57\u0003\u01dc\u00ee\u0000\u0a57\u0a58"+ - "\u0005\u0301\u0000\u0000\u0a58\u0a5a\u0001\u0000\u0000\u0000\u0a59\u0a55"+ - "\u0001\u0000\u0000\u0000\u0a59\u0a5a\u0001\u0000\u0000\u0000\u0a5a\u0a5c"+ - "\u0001\u0000\u0000\u0000\u0a5b\u0a5d\u0005\u0288\u0000\u0000\u0a5c\u0a5b"+ - "\u0001\u0000\u0000\u0000\u0a5c\u0a5d\u0001\u0000\u0000\u0000\u0a5d\u0a60"+ - "\u0001\u0000\u0000\u0000\u0a5e\u0a5f\u0005\u023a\u0000\u0000\u0a5f\u0a61"+ - "\u0003\u0210\u0108\u0000\u0a60\u0a5e\u0001\u0000\u0000\u0000\u0a60\u0a61"+ - "\u0001\u0000\u0000\u0000\u0a61\u0a62\u0001\u0000\u0000\u0000\u0a62\u0a63"+ - "\u0005\u001b\u0000\u0000\u0a63\u0a69\u0003\u0158\u00ac\u0000\u0a64\u0a66"+ - "\u0005\u0288\u0000\u0000\u0a65\u0a67\u0005\u0167\u0000\u0000\u0a66\u0a65"+ - "\u0001\u0000\u0000\u0000\u0a66\u0a67\u0001\u0000\u0000\u0000\u0a67\u0a68"+ - "\u0001\u0000\u0000\u0000\u0a68\u0a6a\u0005\u0091\u0000\u0000\u0a69\u0a64"+ - "\u0001\u0000\u0000\u0000\u0a69\u0a6a\u0001\u0000\u0000\u0000\u0a6a\u0097"+ - "\u0001\u0000\u0000\u0000\u0a6b\u0a6c\u0005~\u0000\u0000\u0a6c\u0a6d\u0005"+ - "\u0184\u0000\u0000\u0a6d\u0a6e\u0003\u0210\u0108\u0000\u0a6e\u0a6f\u0005"+ - "\u0300\u0000\u0000\u0a6f\u0a70\u0005\u01b8\u0000\u0000\u0a70\u0a71\u0005"+ - "\u0319\u0000\u0000\u0a71\u0a76\u0003\u0210\u0108\u0000\u0a72\u0a73\u0005"+ - "\u02fa\u0000\u0000\u0a73\u0a74\u0005\u02c8\u0000\u0000\u0a74\u0a75\u0005"+ - "\u0319\u0000\u0000\u0a75\u0a77\u0003\u01d8\u00ec\u0000\u0a76\u0a72\u0001"+ - "\u0000\u0000\u0000\u0a76\u0a77\u0001\u0000\u0000\u0000\u0a77\u0a7c\u0001"+ - "\u0000\u0000\u0000\u0a78\u0a79\u0005\u02fa\u0000\u0000\u0a79\u0a7a\u0005"+ - "\u02c9\u0000\u0000\u0a7a\u0a7b\u0005\u0319\u0000\u0000\u0a7b\u0a7d\u0003"+ - "\u01d8\u00ec\u0000\u0a7c\u0a78\u0001\u0000\u0000\u0000\u0a7c\u0a7d\u0001"+ - "\u0000\u0000\u0000\u0a7d\u0a82\u0001\u0000\u0000\u0000\u0a7e\u0a7f\u0005"+ - "\u02fa\u0000\u0000\u0a7f\u0a80\u0005\u02ca\u0000\u0000\u0a80\u0a81\u0005"+ - "\u0319\u0000\u0000\u0a81\u0a83\u0003\u01d8\u00ec\u0000\u0a82\u0a7e\u0001"+ - "\u0000\u0000\u0000\u0a82\u0a83\u0001\u0000\u0000\u0000\u0a83\u0a88\u0001"+ - "\u0000\u0000\u0000\u0a84\u0a85\u0005\u02fa\u0000\u0000\u0a85\u0a86\u0005"+ - "\u02cb\u0000\u0000\u0a86\u0a87\u0005\u0319\u0000\u0000\u0a87\u0a89\u0003"+ - "\u01d8\u00ec\u0000\u0a88\u0a84\u0001\u0000\u0000\u0000\u0a88\u0a89\u0001"+ - "\u0000\u0000\u0000\u0a89\u0a8e\u0001\u0000\u0000\u0000\u0a8a\u0a8b\u0005"+ - "\u02fa\u0000\u0000\u0a8b\u0a8c\u0005\u01da\u0000\u0000\u0a8c\u0a8d\u0005"+ - "\u0319\u0000\u0000\u0a8d\u0a8f\u0003\u01d8\u00ec\u0000\u0a8e\u0a8a\u0001"+ - "\u0000\u0000\u0000\u0a8e\u0a8f\u0001\u0000\u0000\u0000\u0a8f\u0a94\u0001"+ - "\u0000\u0000\u0000\u0a90\u0a91\u0005\u02fa\u0000\u0000\u0a91\u0a92\u0005"+ - "\u0124\u0000\u0000\u0a92\u0a93\u0005\u0319\u0000\u0000\u0a93\u0a95\u0003"+ - "\u01d8\u00ec\u0000\u0a94\u0a90\u0001\u0000\u0000\u0000\u0a94\u0a95\u0001"+ - "\u0000\u0000\u0000\u0a95\u0a98\u0001\u0000\u0000\u0000\u0a96\u0a97\u0005"+ - "\u02fa\u0000\u0000\u0a97\u0a99\u0005\u02cc\u0000\u0000\u0a98\u0a96\u0001"+ - "\u0000\u0000\u0000\u0a98\u0a99\u0001\u0000\u0000\u0000\u0a99\u0a9c\u0001"+ - "\u0000\u0000\u0000\u0a9a\u0a9b\u0005\u02fa\u0000\u0000\u0a9b\u0a9d\u0005"+ - "\u02cd\u0000\u0000\u0a9c\u0a9a\u0001\u0000\u0000\u0000\u0a9c\u0a9d\u0001"+ - "\u0000\u0000\u0000\u0a9d\u0a9e\u0001\u0000\u0000\u0000\u0a9e\u0a9f\u0005"+ - "\u0301\u0000\u0000\u0a9f\u0099\u0001\u0000\u0000\u0000\u0aa0\u0aa1\u0005"+ - "\u0184\u0000\u0000\u0aa1\u0aa2\u0005\u0307\u0000\u0000\u0aa2\u0aa9\u0003"+ - "\u0210\u0108\u0000\u0aa3\u0aa4\u0005\u0300\u0000\u0000\u0aa4\u0aa5\u0003"+ - "\u0210\u0108\u0000\u0aa5\u0aa6\u0005\u02fa\u0000\u0000\u0aa6\u0aa7\u0003"+ - "\u0210\u0108\u0000\u0aa7\u0aa8\u0005\u0301\u0000\u0000\u0aa8\u0aaa\u0001"+ - "\u0000\u0000\u0000\u0aa9\u0aa3\u0001\u0000\u0000\u0000\u0aa9\u0aaa\u0001"+ - "\u0000\u0000\u0000\u0aaa\u0abf\u0001\u0000\u0000\u0000\u0aab\u0aac\u0005"+ - "\u00ee\u0000\u0000\u0aac\u0ab5\u0005\u0307\u0000\u0000\u0aad\u0aae\u0005"+ - "\u0300\u0000\u0000\u0aae\u0ab1\u0003\u0210\u0108\u0000\u0aaf\u0ab0\u0005"+ - "\u02fa\u0000\u0000\u0ab0\u0ab2\u0003\u0210\u0108\u0000\u0ab1\u0aaf\u0001"+ - "\u0000\u0000\u0000\u0ab1\u0ab2\u0001\u0000\u0000\u0000\u0ab2\u0ab3\u0001"+ - "\u0000\u0000\u0000\u0ab3\u0ab4\u0005\u0301\u0000\u0000\u0ab4\u0ab6\u0001"+ - "\u0000\u0000\u0000\u0ab5\u0aad\u0001\u0000\u0000\u0000\u0ab5\u0ab6\u0001"+ - "\u0000\u0000\u0000\u0ab6\u0ab7\u0001\u0000\u0000\u0000\u0ab7\u0ab8\u0003"+ - "\u0210\u0108\u0000\u0ab8\u0ab9\u0005\u0300\u0000\u0000\u0ab9\u0aba\u0003"+ - "\u01e6\u00f3\u0000\u0aba\u0abb\u0005\u0301\u0000\u0000\u0abb\u0abf\u0001"+ - "\u0000\u0000\u0000\u0abc\u0abd\u0005\u0229\u0000\u0000\u0abd\u0abf\u0003"+ - "\u0210\u0108\u0000\u0abe\u0aa0\u0001\u0000\u0000\u0000\u0abe\u0aab\u0001"+ - "\u0000\u0000\u0000\u0abe\u0abc\u0001\u0000\u0000\u0000\u0abf\u009b\u0001"+ - "\u0000\u0000\u0000\u0ac0\u0ac1\u0005~\u0000\u0000\u0ac1\u0ac2\u0005\u0184"+ - "\u0000\u0000\u0ac2\u0ac3\u0005Q\u0000\u0000\u0ac3\u0ac5\u0003\u0210\u0108"+ - "\u0000\u0ac4\u0ac6\u0005\u009b\u0000\u0000\u0ac5\u0ac4\u0001\u0000\u0000"+ - "\u0000\u0ac5\u0ac6\u0001\u0000\u0000\u0000\u0ac6\u0ac7\u0001\u0000\u0000"+ - "\u0000\u0ac7\u0ac8\u0005\u00e3\u0000\u0000\u0ac8\u0ac9\u0005\u025d\u0000"+ - "\u0000\u0ac9\u0aca\u0003\u0210\u0108\u0000\u0aca\u0acb\u0005\u0273\u0000"+ - "\u0000\u0acb\u0ace\u0003\u01e8\u00f4\u0000\u0acc\u0acd\u0005\u02ce\u0000"+ - "\u0000\u0acd\u0acf\u0003\u0210\u0108\u0000\u0ace\u0acc\u0001\u0000\u0000"+ - "\u0000\u0ace\u0acf\u0001\u0000\u0000\u0000\u0acf\u0ad0\u0001\u0000\u0000"+ - "\u0000\u0ad0\u0ad1\u0005\u001b\u0000\u0000\u0ad1\u0ad6\u0003\u009aM\u0000"+ - "\u0ad2\u0ad3\u0005\u02fa\u0000\u0000\u0ad3\u0ad5\u0003\u009aM\u0000\u0ad4"+ - "\u0ad2\u0001\u0000\u0000\u0000\u0ad5\u0ad8\u0001\u0000\u0000\u0000\u0ad6"+ - "\u0ad4\u0001\u0000\u0000\u0000\u0ad6\u0ad7\u0001\u0000\u0000\u0000\u0ad7"+ - "\u009d\u0001\u0000\u0000\u0000\u0ad8\u0ad6\u0001\u0000\u0000\u0000\u0ad9"+ - "\u0ada\u0005~\u0000\u0000\u0ada\u0adb\u0005\u0184\u0000\u0000\u0adb\u0adc"+ - "\u0005\u02ce\u0000\u0000\u0adc\u0add\u0003\u0210\u0108\u0000\u0add\u0ade"+ - "\u0005\u0273\u0000\u0000\u0ade\u0adf\u0003\u01e8\u00f4\u0000\u0adf\u009f"+ - "\u0001\u0000\u0000\u0000\u0ae0\u0ae1\u0005~\u0000\u0000\u0ae1\u0ae2\u0005"+ - "\u02cf\u0000\u0000\u0ae2\u0ae3\u0003\u0210\u0108\u0000\u0ae3\u0ae4\u0005"+ - "\u0180\u0000\u0000\u0ae4\u0ae7\u0003\u0210\u0108\u0000\u0ae5\u0ae6\u0005"+ - "\u00e3\u0000\u0000\u0ae6\u0ae8\u0007\n\u0000\u0000\u0ae7\u0ae5\u0001\u0000"+ - "\u0000\u0000\u0ae7\u0ae8\u0001\u0000\u0000\u0000\u0ae8\u0aeb\u0001\u0000"+ - "\u0000\u0000\u0ae9\u0aea\u0005\u0247\u0000\u0000\u0aea\u0aec\u0003\u0206"+ - "\u0103\u0000\u0aeb\u0ae9\u0001\u0000\u0000\u0000\u0aeb\u0aec\u0001\u0000"+ - "\u0000\u0000\u0aec\u0af2\u0001\u0000\u0000\u0000\u0aed\u0aee\u0005\u0273"+ - "\u0000\u0000\u0aee\u0aef\u0005\u0300\u0000\u0000\u0aef\u0af0\u0003\u01f8"+ - "\u00fc\u0000\u0af0\u0af1\u0005\u0301\u0000\u0000\u0af1\u0af3\u0001\u0000"+ - "\u0000\u0000\u0af2\u0aed\u0001\u0000\u0000\u0000\u0af2\u0af3\u0001\u0000"+ - "\u0000\u0000\u0af3\u0afa\u0001\u0000\u0000\u0000\u0af4\u0af5\u0005\u0288"+ - "\u0000\u0000\u0af5\u0af6\u0005N\u0000\u0000\u0af6\u0af7\u0005\u0300\u0000"+ - "\u0000\u0af7\u0af8\u0003\u01f8\u00fc\u0000\u0af8\u0af9\u0005\u0301\u0000"+ - "\u0000\u0af9\u0afb\u0001\u0000\u0000\u0000\u0afa\u0af4\u0001\u0000\u0000"+ - "\u0000\u0afa\u0afb\u0001\u0000\u0000\u0000\u0afb\u00a1\u0001\u0000\u0000"+ - "\u0000\u0afc\u0afd\u0005~\u0000\u0000\u0afd\u0afe\u0005\u01e5\u0000\u0000"+ - "\u0afe\u0b2d\u0003\u0206\u0103\u0000\u0aff\u0b01\u0005\u0288\u0000\u0000"+ - "\u0b00\u0aff\u0001\u0000\u0000\u0000\u0b00\u0b01\u0001\u0000\u0000\u0000"+ - "\u0b01\u0b29\u0001\u0000\u0000\u0000\u0b02\u0b2a\u0005\u0291\u0000\u0000"+ - "\u0b03\u0b2a\u0005\u0292\u0000\u0000\u0b04\u0b2a\u0005\u007f\u0000\u0000"+ - "\u0b05\u0b2a\u0005\u0168\u0000\u0000\u0b06\u0b2a\u0005\u0293\u0000\u0000"+ - "\u0b07\u0b2a\u0005\u0294\u0000\u0000\u0b08\u0b2a\u0005\u0295\u0000\u0000"+ - "\u0b09\u0b2a\u0005\u0296\u0000\u0000\u0b0a\u0b2a\u0005\u0297\u0000\u0000"+ - "\u0b0b\u0b2a\u0005\u0298\u0000\u0000\u0b0c\u0b2a\u0005\u0299\u0000\u0000"+ - "\u0b0d\u0b2a\u0005\u029a\u0000\u0000\u0b0e\u0b2a\u0005\u029b\u0000\u0000"+ - "\u0b0f\u0b2a\u0005\u029c\u0000\u0000\u0b10\u0b11\u0005k\u0000\u0000\u0b11"+ - "\u0b12\u0005\u0136\u0000\u0000\u0b12\u0b2a\u0003\u01bc\u00de\u0000\u0b13"+ - "\u0b15\u0005\u00c5\u0000\u0000\u0b14\u0b13\u0001\u0000\u0000\u0000\u0b14"+ - "\u0b15\u0001\u0000\u0000\u0000\u0b15\u0b16\u0001\u0000\u0000\u0000\u0b16"+ - "\u0b17\u0005\u01a1\u0000\u0000\u0b17\u0b2a\u0007\t\u0000\u0000\u0b18\u0b19"+ - "\u0005\u0275\u0000\u0000\u0b19\u0b1a\u0005\u026a\u0000\u0000\u0b1a\u0b2a"+ - "\u0005\u030a\u0000\u0000\u0b1b\u0b1c\u0005\u0109\u0000\u0000\u0b1c\u0b1d"+ - "\u0005\u01e5\u0000\u0000\u0b1d\u0b2a\u0003\u01da\u00ed\u0000\u0b1e\u0b1f"+ - "\u0005\u0109\u0000\u0000\u0b1f\u0b20\u0005\u00fa\u0000\u0000\u0b20\u0b2a"+ - "\u0003\u01da\u00ed\u0000\u0b21\u0b22\u0005\u01e5\u0000\u0000\u0b22\u0b2a"+ - "\u0003\u01da\u00ed\u0000\u0b23\u0b24\u0005\f\u0000\u0000\u0b24\u0b2a\u0003"+ - "\u01da\u00ed\u0000\u0b25\u0b26\u0005\u026e\u0000\u0000\u0b26\u0b2a\u0003"+ - "\u01da\u00ed\u0000\u0b27\u0b28\u0005\u0234\u0000\u0000\u0b28\u0b2a\u0005"+ - "\u0307\u0000\u0000\u0b29\u0b02\u0001\u0000\u0000\u0000\u0b29\u0b03\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b04\u0001\u0000\u0000\u0000\u0b29\u0b05\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b06\u0001\u0000\u0000\u0000\u0b29\u0b07\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b08\u0001\u0000\u0000\u0000\u0b29\u0b09\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b0a\u0001\u0000\u0000\u0000\u0b29\u0b0b\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b0c\u0001\u0000\u0000\u0000\u0b29\u0b0d\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b0e\u0001\u0000\u0000\u0000\u0b29\u0b0f\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b10\u0001\u0000\u0000\u0000\u0b29\u0b14\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b18\u0001\u0000\u0000\u0000\u0b29\u0b1b\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b1e\u0001\u0000\u0000\u0000\u0b29\u0b21\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b23\u0001\u0000\u0000\u0000\u0b29\u0b25\u0001"+ - "\u0000\u0000\u0000\u0b29\u0b27\u0001\u0000\u0000\u0000\u0b2a\u0b2b\u0001"+ - "\u0000\u0000\u0000\u0b2b\u0b29\u0001\u0000\u0000\u0000\u0b2b\u0b2c\u0001"+ - "\u0000\u0000\u0000\u0b2c\u0b2e\u0001\u0000\u0000\u0000\u0b2d\u0b00\u0001"+ - "\u0000\u0000\u0000\u0b2d\u0b2e\u0001\u0000\u0000\u0000\u0b2e\u00a3\u0001"+ - "\u0000\u0000\u0000\u0b2f\u0b30\u0007\u000b\u0000\u0000\u0b30\u00a5\u0001"+ - "\u0000\u0000\u0000\u0b31\u0b34\u0005~\u0000\u0000\u0b32\u0b33\u0005\u0187"+ - "\u0000\u0000\u0b33\u0b35\u0005\u01d6\u0000\u0000\u0b34\u0b32\u0001\u0000"+ - "\u0000\u0000\u0b34\u0b35\u0001\u0000\u0000\u0000\u0b35\u0b36\u0001\u0000"+ - "\u0000\u0000\u0b36\u0b37\u0005\u01f0\u0000\u0000\u0b37\u0b38\u0003\u01d8"+ - "\u00ec\u0000\u0b38\u0b39\u0005\u001b\u0000\u0000\u0b39\u0b3a\u0005\u0180"+ - "\u0000\u0000\u0b3a\u0b3b\u0003\u00a4R\u0000\u0b3b\u0b3c\u0005\u0247\u0000"+ - "\u0000\u0b3c\u0b3f\u0003\u0210\u0108\u0000\u0b3d\u0b3e\u0005\u0285\u0000"+ - "\u0000\u0b3e\u0b40\u0003\u01f8\u00fc\u0000\u0b3f\u0b3d\u0001\u0000\u0000"+ - "\u0000\u0b3f\u0b40\u0001\u0000\u0000\u0000\u0b40\u0b41\u0001\u0000\u0000"+ - "\u0000\u0b41\u0b43\u0005\u00b9\u0000\u0000\u0b42\u0b44\u0007\f\u0000\u0000"+ - "\u0b43\u0b42\u0001\u0000\u0000\u0000\u0b43\u0b44\u0001\u0000\u0000\u0000"+ - "\u0b44\u0b47\u0001\u0000\u0000\u0000\u0b45\u0b48\u0005\u016e\u0000\u0000"+ - "\u0b46\u0b48\u0003\u0210\u0108\u0000\u0b47\u0b45\u0001\u0000\u0000\u0000"+ - "\u0b47\u0b46\u0001\u0000\u0000\u0000\u0b48\u00a7\u0001\u0000\u0000\u0000"+ - "\u0b49\u0b4a\u0005~\u0000\u0000\u0b4a\u0b4b\u0005\u01f3\u0000\u0000\u0b4b"+ - "\u0b4e\u0003\u0210\u0108\u0000\u0b4c\u0b4d\u0005%\u0000\u0000\u0b4d\u0b4f"+ - "\u0003\u0206\u0103\u0000\u0b4e\u0b4c\u0001\u0000\u0000\u0000\u0b4e\u0b4f"+ - "\u0001\u0000\u0000\u0000\u0b4f\u0b51\u0001\u0000\u0000\u0000\u0b50\u0b52"+ - "\u0003\u0212\u0109\u0000\u0b51\u0b50\u0001\u0000\u0000\u0000\u0b51\u0b52"+ - "\u0001\u0000\u0000\u0000\u0b52\u0b6c\u0001\u0000\u0000\u0000\u0b53\u0b54"+ - "\u0005~\u0000\u0000\u0b54\u0b55\u0005\u01f3\u0000\u0000\u0b55\u0b56\u0005"+ - "%\u0000\u0000\u0b56\u0b58\u0003\u0206\u0103\u0000\u0b57\u0b59\u0003\u0212"+ - "\u0109\u0000\u0b58\u0b57\u0001\u0000\u0000\u0000\u0b58\u0b59\u0001\u0000"+ - "\u0000\u0000\u0b59\u0b6c\u0001\u0000\u0000\u0000\u0b5a\u0b5b\u0005~\u0000"+ - "\u0000\u0b5b\u0b5c\u0005\u01f3\u0000\u0000\u0b5c\u0b5d\u0005\u02b4\u0000"+ - "\u0000\u0b5d\u0b5e\u0005\u016d\u0000\u0000\u0b5e\u0b5f\u0005\u00d3\u0000"+ - "\u0000\u0b5f\u0b62\u0003\u0210\u0108\u0000\u0b60\u0b61\u0005%\u0000\u0000"+ - "\u0b61\u0b63\u0003\u0206\u0103\u0000\u0b62\u0b60\u0001\u0000\u0000\u0000"+ - "\u0b62\u0b63\u0001\u0000\u0000\u0000\u0b63\u0b6c\u0001\u0000\u0000\u0000"+ - "\u0b64\u0b65\u0005~\u0000\u0000\u0b65\u0b66\u0005\u01f3\u0000\u0000\u0b66"+ - "\u0b67\u0005\u02b4\u0000\u0000\u0b67\u0b68\u0005\u016d\u0000\u0000\u0b68"+ - "\u0b69\u0005\u00d3\u0000\u0000\u0b69\u0b6a\u0005%\u0000\u0000\u0b6a\u0b6c"+ - "\u0003\u0206\u0103\u0000\u0b6b\u0b49\u0001\u0000\u0000\u0000\u0b6b\u0b53"+ - "\u0001\u0000\u0000\u0000\u0b6b\u0b5a\u0001\u0000\u0000\u0000\u0b6b\u0b64"+ - "\u0001\u0000\u0000\u0000\u0b6c\u00a9\u0001\u0000\u0000\u0000\u0b6d\u0b6f"+ - "\u0005~\u0000\u0000\u0b6e\u0b70\u0007\r\u0000\u0000\u0b6f\u0b6e\u0001"+ - "\u0000\u0000\u0000\u0b6f\u0b70\u0001\u0000\u0000\u0000\u0b70\u0b71\u0001"+ - "\u0000\u0000\u0000\u0b71\u0b75\u0005\u0201\u0000\u0000\u0b72\u0b73\u0005"+ - "\u02b4\u0000\u0000\u0b73\u0b74\u0005\u016d\u0000\u0000\u0b74\u0b76\u0005"+ - "\u00d3\u0000\u0000\u0b75\u0b72\u0001\u0000\u0000\u0000\u0b75\u0b76\u0001"+ - "\u0000\u0000\u0000\u0b76\u0b77\u0001\u0000\u0000\u0000\u0b77\u0b7d\u0003"+ - "\u0210\u0108\u0000\u0b78\u0b7a\u0005\u010b\u0000\u0000\u0b79\u0b7b\u0005"+ - "6\u0000\u0000\u0b7a\u0b79\u0001\u0000\u0000\u0000\u0b7a\u0b7b\u0001\u0000"+ - "\u0000\u0000\u0b7b\u0b7c\u0001\u0000\u0000\u0000\u0b7c\u0b7e\u0003\u01bc"+ - "\u00de\u0000\u0b7d\u0b78\u0001\u0000\u0000\u0000\u0b7d\u0b7e\u0001\u0000"+ - "\u0000\u0000\u0b7e\u0b83\u0001\u0000\u0000\u0000\u0b7f\u0b80\u0005\u0153"+ - "\u0000\u0000\u0b80\u0b84\u0003\u01bc\u00de\u0000\u0b81\u0b82\u0005\u0167"+ - "\u0000\u0000\u0b82\u0b84\u0005\u0153\u0000\u0000\u0b83\u0b7f\u0001\u0000"+ - "\u0000\u0000\u0b83\u0b81\u0001\u0000\u0000\u0000\u0b83\u0b84\u0001\u0000"+ - "\u0000\u0000\u0b84\u0b89\u0001\u0000\u0000\u0000\u0b85\u0b86\u0005\u014a"+ - "\u0000\u0000\u0b86\u0b8a\u0003\u01bc\u00de\u0000\u0b87\u0b88\u0005\u0167"+ - "\u0000\u0000\u0b88\u0b8a\u0005\u014a\u0000\u0000\u0b89\u0b85\u0001\u0000"+ - "\u0000\u0000\u0b89\u0b87\u0001\u0000\u0000\u0000\u0b89\u0b8a\u0001\u0000"+ - "\u0000\u0000\u0b8a\u0b90\u0001\u0000\u0000\u0000\u0b8b\u0b8d\u0005\u0220"+ - "\u0000\u0000\u0b8c\u0b8e\u0005\u0288\u0000\u0000\u0b8d\u0b8c\u0001\u0000"+ - "\u0000\u0000\u0b8d\u0b8e\u0001\u0000\u0000\u0000\u0b8e\u0b8f\u0001\u0000"+ - "\u0000\u0000\u0b8f\u0b91\u0003\u01bc\u00de\u0000\u0b90\u0b8b\u0001\u0000"+ - "\u0000\u0000\u0b90\u0b91\u0001\u0000\u0000\u0000\u0b91\u0b94\u0001\u0000"+ - "\u0000\u0000\u0b92\u0b93\u00058\u0000\u0000\u0b93\u0b95\u0003\u01bc\u00de"+ - "\u0000\u0b94\u0b92\u0001\u0000\u0000\u0000\u0b94\u0b95\u0001\u0000\u0000"+ - "\u0000\u0b95\u0b9a\u0001\u0000\u0000\u0000\u0b96\u0b98\u0005\u0167\u0000"+ - "\u0000\u0b97\u0b96\u0001\u0000\u0000\u0000\u0b97\u0b98\u0001\u0000\u0000"+ - "\u0000\u0b98\u0b99\u0001\u0000\u0000\u0000\u0b99\u0b9b\u0005\u0090\u0000"+ - "\u0000\u0b9a\u0b97\u0001\u0000\u0000\u0000\u0b9a\u0b9b\u0001\u0000\u0000"+ - "\u0000\u0b9b\u0ba5\u0001\u0000\u0000\u0000\u0b9c\u0b9d\u0005\u02d0\u0000"+ - "\u0000\u0b9d\u0ba3\u00056\u0000\u0000\u0b9e\u0b9f\u0003\u0210\u0108\u0000"+ - "\u0b9f\u0ba0\u0005\u0309\u0000\u0000\u0ba0\u0ba1\u0003\u0210\u0108\u0000"+ - "\u0ba1\u0ba4\u0001\u0000\u0000\u0000\u0ba2\u0ba4\u0005\u016a\u0000\u0000"+ - "\u0ba3\u0b9e\u0001\u0000\u0000\u0000\u0ba3\u0ba2\u0001\u0000\u0000\u0000"+ - "\u0ba4\u0ba6\u0001\u0000\u0000\u0000\u0ba5\u0b9c\u0001\u0000\u0000\u0000"+ - "\u0ba5\u0ba6\u0001\u0000\u0000\u0000\u0ba6\u00ab\u0001\u0000\u0000\u0000"+ - "\u0ba7\u0ba8\u0003\u0214\u010a\u0000\u0ba8\u00ad\u0001\u0000\u0000\u0000"+ - "\u0ba9\u0baa\u0003\u0214\u010a\u0000\u0baa\u00af\u0001\u0000\u0000\u0000"+ - "\u0bab\u0bac\u0003\u0214\u010a\u0000\u0bac\u00b1\u0001\u0000\u0000\u0000"+ - "\u0bad\u0bae\u0003\u0214\u010a\u0000\u0bae\u00b3\u0001\u0000\u0000\u0000"+ - "\u0baf\u0bb0\u0003\u0214\u010a\u0000\u0bb0\u00b5\u0001\u0000\u0000\u0000"+ - "\u0bb1\u0bb2\u0003\u0214\u010a\u0000\u0bb2\u00b7\u0001\u0000\u0000\u0000"+ - "\u0bb3\u0bb4\u0003\u0214\u010a\u0000\u0bb4\u00b9\u0001\u0000\u0000\u0000"+ - "\u0bb5\u0bb6\u0003\u0214\u010a\u0000\u0bb6\u00bb\u0001\u0000\u0000\u0000"+ - "\u0bb7\u0bb8\u0003\u0214\u010a\u0000\u0bb8\u00bd\u0001\u0000\u0000\u0000"+ - "\u0bb9\u0bba\u0003\u0214\u010a\u0000\u0bba\u00bf\u0001\u0000\u0000\u0000"+ - "\u0bbb\u0bbc\u0003\u0214\u010a\u0000\u0bbc\u00c1\u0001\u0000\u0000\u0000"+ - "\u0bbd\u0bbe\u0003\u0214\u010a\u0000\u0bbe\u00c3\u0001\u0000\u0000\u0000"+ - "\u0bbf\u0bc0\u0003\u0214\u010a\u0000\u0bc0\u00c5\u0001\u0000\u0000\u0000"+ - "\u0bc1\u0bc2\u0003\u0214\u010a\u0000\u0bc2\u00c7\u0001\u0000\u0000\u0000"+ - "\u0bc3\u0bc4\u0003\u0214\u010a\u0000\u0bc4\u00c9\u0001\u0000\u0000\u0000"+ - "\u0bc5\u0bc8\u0005~\u0000\u0000\u0bc6\u0bc7\u0005\u0187\u0000\u0000\u0bc7"+ - "\u0bc9\u0005\u01d6\u0000\u0000\u0bc8\u0bc6\u0001\u0000\u0000\u0000\u0bc8"+ - "\u0bc9\u0001\u0000\u0000\u0000\u0bc9\u0bcb\u0001\u0000\u0000\u0000\u0bca"+ - "\u0bcc\u0007\r\u0000\u0000\u0bcb\u0bca\u0001\u0000\u0000\u0000\u0bcb\u0bcc"+ - "\u0001\u0000\u0000\u0000\u0bcc\u0bce\u0001\u0000\u0000\u0000\u0bcd\u0bcf"+ - "\u0005\u01c3\u0000\u0000\u0bce\u0bcd\u0001\u0000\u0000\u0000\u0bce\u0bcf"+ - "\u0001\u0000\u0000\u0000\u0bcf\u0bd0\u0001\u0000\u0000\u0000\u0bd0\u0bd1"+ - "\u0005\u0281\u0000\u0000\u0bd1\u0bd6\u0003\u01d8\u00ec\u0000\u0bd2\u0bd3"+ - "\u0005\u0300\u0000\u0000\u0bd3\u0bd4\u0003\u01da\u00ed\u0000\u0bd4\u0bd5"+ - "\u0005\u0301\u0000\u0000\u0bd5\u0bd7\u0001\u0000\u0000\u0000\u0bd6\u0bd2"+ - "\u0001\u0000\u0000\u0000\u0bd6\u0bd7\u0001\u0000\u0000\u0000\u0bd7\u0bdd"+ - "\u0001\u0000\u0000\u0000\u0bd8\u0bd9\u0005\u0288\u0000\u0000\u0bd9\u0bda"+ - "\u0005\u0300\u0000\u0000\u0bda\u0bdb\u0003\u01e0\u00f0\u0000\u0bdb\u0bdc"+ - "\u0005\u0301\u0000\u0000\u0bdc\u0bde\u0001\u0000\u0000\u0000\u0bdd\u0bd8"+ - "\u0001\u0000\u0000\u0000\u0bdd\u0bde\u0001\u0000\u0000\u0000\u0bde\u0bdf"+ - "\u0001\u0000\u0000\u0000\u0bdf\u0be2\u0005\u001b\u0000\u0000\u0be0\u0be3"+ - "\u0003\u0158\u00ac\u0000\u0be1\u0be3\u0003\u017c\u00be\u0000\u0be2\u0be0"+ - "\u0001\u0000\u0000\u0000\u0be2\u0be1\u0001\u0000\u0000\u0000\u0be3\u0bea"+ - "\u0001\u0000\u0000\u0000\u0be4\u0be6\u0005\u0288\u0000\u0000\u0be5\u0be7"+ - "\u0007\u000e\u0000\u0000\u0be6\u0be5\u0001\u0000\u0000\u0000\u0be6\u0be7"+ - "\u0001\u0000\u0000\u0000\u0be7\u0be8\u0001\u0000\u0000\u0000\u0be8\u0be9"+ - "\u0005N\u0000\u0000\u0be9\u0beb\u0005\u0185\u0000\u0000\u0bea\u0be4\u0001"+ - "\u0000\u0000\u0000\u0bea\u0beb\u0001\u0000\u0000\u0000\u0beb\u00cb\u0001"+ - "\u0000\u0000\u0000\u0bec\u0bed\u0003\u0214\u010a\u0000\u0bed\u00cd\u0001"+ - "\u0000\u0000\u0000\u0bee\u0bef\u0003\u0214\u010a\u0000\u0bef\u00cf\u0001"+ - "\u0000\u0000\u0000\u0bf0\u0bf2\u0003\u015c\u00ae\u0000\u0bf1\u0bf0\u0001"+ - "\u0000\u0000\u0000\u0bf1\u0bf2\u0001\u0000\u0000\u0000\u0bf2\u0bf3\u0001"+ - "\u0000\u0000\u0000\u0bf3\u0bf4\u0005\u00a3\u0000\u0000\u0bf4\u0bf6\u0005"+ - "\u00ec\u0000\u0000\u0bf5\u0bf7\u0005\u0181\u0000\u0000\u0bf6\u0bf5\u0001"+ - "\u0000\u0000\u0000\u0bf6\u0bf7\u0001\u0000\u0000\u0000\u0bf7\u0bf8\u0001"+ - "\u0000\u0000\u0000\u0bf8\u0bfa\u0003\u01e2\u00f1\u0000\u0bf9\u0bfb\u0005"+ - "\u02ff\u0000\u0000\u0bfa\u0bf9\u0001\u0000\u0000\u0000\u0bfa\u0bfb\u0001"+ - "\u0000\u0000\u0000\u0bfb\u0c00\u0001\u0000\u0000\u0000\u0bfc\u0bfe\u0005"+ - "\u001b\u0000\u0000\u0bfd\u0bfc\u0001\u0000\u0000\u0000\u0bfd\u0bfe\u0001"+ - "\u0000\u0000\u0000\u0bfe\u0bff\u0001\u0000\u0000\u0000\u0bff\u0c01\u0003"+ - "\u021a\u010d\u0000\u0c00\u0bfd\u0001\u0000\u0000\u0000\u0c00\u0c01\u0001"+ - "\u0000\u0000\u0000\u0c01\u0c04\u0001\u0000\u0000\u0000\u0c02\u0c03\u0005"+ - "\u0273\u0000\u0000\u0c03\u0c05\u0003\u01dc\u00ee\u0000\u0c04\u0c02\u0001"+ - "\u0000\u0000\u0000\u0c04\u0c05\u0001\u0000\u0000\u0000\u0c05\u0c0b\u0001"+ - "\u0000\u0000\u0000\u0c06\u0c0c\u0003\u0182\u00c1\u0000\u0c07\u0c08\u0005"+ - "\u0285\u0000\u0000\u0c08\u0c09\u0005\u0085\u0000\u0000\u0c09\u0c0a\u0005"+ - "\u017b\u0000\u0000\u0c0a\u0c0c\u0003\u0210\u0108\u0000\u0c0b\u0c06\u0001"+ - "\u0000\u0000\u0000\u0c0b\u0c07\u0001\u0000\u0000\u0000\u0c0b\u0c0c\u0001"+ - "\u0000\u0000\u0000\u0c0c\u0c0e\u0001\u0000\u0000\u0000\u0c0d\u0c0f\u0003"+ - "\u01b6\u00db\u0000\u0c0e\u0c0d\u0001\u0000\u0000\u0000\u0c0e\u0c0f\u0001"+ - "\u0000\u0000\u0000\u0c0f\u00d1\u0001\u0000\u0000\u0000\u0c10\u0c11\u0005"+ - "\u00b5\u0000\u0000\u0c11\u0c12\u0007\u000f\u0000\u0000\u0c12\u00d3\u0001"+ - "\u0000\u0000\u0000\u0c13\u0c3d\u0003\u00d6k\u0000\u0c14\u0c3d\u0003\u00d8"+ - "l\u0000\u0c15\u0c3d\u0003\u00dam\u0000\u0c16\u0c3d\u0003\u00dcn\u0000"+ - "\u0c17\u0c3d\u0003\u00deo\u0000\u0c18\u0c3d\u0003\u00e0p\u0000\u0c19\u0c3d"+ - "\u0003\u00e2q\u0000\u0c1a\u0c3d\u0003\u00e4r\u0000\u0c1b\u0c3d\u0003\u00e6"+ - "s\u0000\u0c1c\u0c3d\u0003\u00e8t\u0000\u0c1d\u0c3d\u0003\u00eau\u0000"+ - "\u0c1e\u0c3d\u0003\u00ecv\u0000\u0c1f\u0c3d\u0003\u00eew\u0000\u0c20\u0c3d"+ - "\u0003\u00f0x\u0000\u0c21\u0c3d\u0003\u00f2y\u0000\u0c22\u0c3d\u0003\u00f4"+ - "z\u0000\u0c23\u0c3d\u0003\u00f6{\u0000\u0c24\u0c3d\u0003\u00f8|\u0000"+ - "\u0c25\u0c3d\u0003\u00fa}\u0000\u0c26\u0c3d\u0003\u00fc~\u0000\u0c27\u0c3d"+ - "\u0003\u00fe\u007f\u0000\u0c28\u0c3d\u0003\u0100\u0080\u0000\u0c29\u0c3d"+ - "\u0003\u0102\u0081\u0000\u0c2a\u0c3d\u0003\u0104\u0082\u0000\u0c2b\u0c3d"+ - "\u0003\u0106\u0083\u0000\u0c2c\u0c3d\u0003\u0108\u0084\u0000\u0c2d\u0c3d"+ - "\u0003\u010a\u0085\u0000\u0c2e\u0c3d\u0003\u010c\u0086\u0000\u0c2f\u0c3d"+ - "\u0003\u010e\u0087\u0000\u0c30\u0c3d\u0003\u0110\u0088\u0000\u0c31\u0c3d"+ - "\u0003\u0112\u0089\u0000\u0c32\u0c3d\u0003\u0114\u008a\u0000\u0c33\u0c3d"+ - "\u0003\u0116\u008b\u0000\u0c34\u0c3d\u0003\u0118\u008c\u0000\u0c35\u0c3d"+ - "\u0003\u011a\u008d\u0000\u0c36\u0c3d\u0003\u011c\u008e\u0000\u0c37\u0c3d"+ - "\u0003\u011e\u008f\u0000\u0c38\u0c3d\u0003\u0120\u0090\u0000\u0c39\u0c3d"+ - "\u0003\u0122\u0091\u0000\u0c3a\u0c3d\u0003\u0124\u0092\u0000\u0c3b\u0c3d"+ - "\u0003\u0126\u0093\u0000\u0c3c\u0c13\u0001\u0000\u0000\u0000\u0c3c\u0c14"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c15\u0001\u0000\u0000\u0000\u0c3c\u0c16"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c17\u0001\u0000\u0000\u0000\u0c3c\u0c18"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c19\u0001\u0000\u0000\u0000\u0c3c\u0c1a"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c1b\u0001\u0000\u0000\u0000\u0c3c\u0c1c"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c1d\u0001\u0000\u0000\u0000\u0c3c\u0c1e"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c1f\u0001\u0000\u0000\u0000\u0c3c\u0c20"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c21\u0001\u0000\u0000\u0000\u0c3c\u0c22"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c23\u0001\u0000\u0000\u0000\u0c3c\u0c24"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c25\u0001\u0000\u0000\u0000\u0c3c\u0c26"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c27\u0001\u0000\u0000\u0000\u0c3c\u0c28"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c29\u0001\u0000\u0000\u0000\u0c3c\u0c2a"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c2b\u0001\u0000\u0000\u0000\u0c3c\u0c2c"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c2d\u0001\u0000\u0000\u0000\u0c3c\u0c2e"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c2f\u0001\u0000\u0000\u0000\u0c3c\u0c30"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c31\u0001\u0000\u0000\u0000\u0c3c\u0c32"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c33\u0001\u0000\u0000\u0000\u0c3c\u0c34"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c35\u0001\u0000\u0000\u0000\u0c3c\u0c36"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c37\u0001\u0000\u0000\u0000\u0c3c\u0c38"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c39\u0001\u0000\u0000\u0000\u0c3c\u0c3a"+ - "\u0001\u0000\u0000\u0000\u0c3c\u0c3b\u0001\u0000\u0000\u0000\u0c3d\u00d5"+ - "\u0001\u0000\u0000\u0000\u0c3e\u0c3f\u0005\u00bc\u0000\u0000\u0c3f\u0c40"+ - "\u0005\b\u0000\u0000\u0c40\u0c43\u0005\u0150\u0000\u0000\u0c41\u0c42\u0005"+ - "\u02b4\u0000\u0000\u0c42\u0c44\u0005\u00d3\u0000\u0000\u0c43\u0c41\u0001"+ - "\u0000\u0000\u0000\u0c43\u0c44\u0001\u0000\u0000\u0000\u0c44\u0c45\u0001"+ - "\u0000\u0000\u0000\u0c45\u0c47\u0003\u0210\u0108\u0000\u0c46\u0c48\u0007"+ - "\u0001\u0000\u0000\u0c47\u0c46\u0001\u0000\u0000\u0000\u0c47\u0c48\u0001"+ - "\u0000\u0000\u0000\u0c48\u00d7\u0001\u0000\u0000\u0000\u0c49\u0c4a\u0005"+ - "\u00bc\u0000\u0000\u0c4a\u0c4d\u0005\u000e\u0000\u0000\u0c4b\u0c4c\u0005"+ - "\u02b4\u0000\u0000\u0c4c\u0c4e\u0005\u00d3\u0000\u0000\u0c4d\u0c4b\u0001"+ - "\u0000\u0000\u0000\u0c4d\u0c4e\u0001\u0000\u0000\u0000\u0c4e\u0c4f\u0001"+ - "\u0000\u0000\u0000\u0c4f\u0c50\u0003\u0210\u0108\u0000\u0c50\u0c51\u0005"+ - "\u0300\u0000\u0000\u0c51\u0c52\u0003\u01fa\u00fd\u0000\u0c52\u0c53\u0005"+ - "\u0301\u0000\u0000\u0c53\u00d9\u0001\u0000\u0000\u0000\u0c54\u0c55\u0005"+ - "\u00bc\u0000\u0000\u0c55\u0c58\u0005?\u0000\u0000\u0c56\u0c57\u0005\u02b4"+ - "\u0000\u0000\u0c57\u0c59\u0005\u00d3\u0000\u0000\u0c58\u0c56\u0001\u0000"+ - "\u0000\u0000\u0c58\u0c59\u0001\u0000\u0000\u0000\u0c59\u0c5a\u0001\u0000"+ - "\u0000\u0000\u0c5a\u0c5b\u0005\u0300\u0000\u0000\u0c5b\u0c5c\u0003\u01e4"+ - "\u00f2\u0000\u0c5c\u0c5d\u0005\u001b\u0000\u0000\u0c5d\u0c5e\u0003\u0210"+ - "\u0108\u0000\u0c5e\u0c60\u0005\u0301\u0000\u0000\u0c5f\u0c61\u0007\u0001"+ - "\u0000\u0000\u0c60\u0c5f\u0001\u0000\u0000\u0000\u0c60\u0c61\u0001\u0000"+ - "\u0000\u0000\u0c61\u00db\u0001\u0000\u0000\u0000\u0c62\u0c63\u0005\u00bc"+ - "\u0000\u0000\u0c63\u0c66\u0005Y\u0000\u0000\u0c64\u0c65\u0005\u02b4\u0000"+ - "\u0000\u0c65\u0c67\u0005\u00d3\u0000\u0000\u0c66\u0c64\u0001\u0000\u0000"+ - "\u0000\u0c66\u0c67\u0001\u0000\u0000\u0000\u0c67\u0c68\u0001\u0000\u0000"+ - "\u0000\u0c68\u0c6a\u0003\u01dc\u00ee\u0000\u0c69\u0c6b\u0007\u0001\u0000"+ - "\u0000\u0c6a\u0c69\u0001\u0000\u0000\u0000\u0c6a\u0c6b\u0001\u0000\u0000"+ - "\u0000\u0c6b\u00dd\u0001\u0000\u0000\u0000\u0c6c\u0c6d\u0005\u00bc\u0000"+ - "\u0000\u0c6d\u0c70\u0005u\u0000\u0000\u0c6e\u0c6f\u0005\u02b4\u0000\u0000"+ - "\u0c6f\u0c71\u0005\u00d3\u0000\u0000\u0c70\u0c6e\u0001\u0000\u0000\u0000"+ - "\u0c70\u0c71\u0001\u0000\u0000\u0000\u0c71\u0c72\u0001\u0000\u0000\u0000"+ - "\u0c72\u0c74\u0003\u0210\u0108\u0000\u0c73\u0c75\u0007\u0001\u0000\u0000"+ - "\u0c74\u0c73\u0001\u0000\u0000\u0000\u0c74\u0c75\u0001\u0000\u0000\u0000"+ - "\u0c75\u00df\u0001\u0000\u0000\u0000\u0c76\u0c77\u0005\u00bc\u0000\u0000"+ - "\u0c77\u0c7a\u0005\u0092\u0000\u0000\u0c78\u0c79\u0005\u02b4\u0000\u0000"+ - "\u0c79\u0c7b\u0005\u00d3\u0000\u0000\u0c7a\u0c78\u0001\u0000\u0000\u0000"+ - "\u0c7a\u0c7b\u0001\u0000\u0000\u0000\u0c7b\u0c7c\u0001\u0000\u0000\u0000"+ - "\u0c7c\u0c7d\u0003\u0210\u0108\u0000\u0c7d\u00e1\u0001\u0000\u0000\u0000"+ - "\u0c7e\u0c7f\u0005\u00bc\u0000\u0000\u0c7f\u0c82\u0005\u00ba\u0000\u0000"+ - "\u0c80\u0c81\u0005\u02b4\u0000\u0000\u0c81\u0c83\u0005\u00d3\u0000\u0000"+ - "\u0c82\u0c80\u0001\u0000\u0000\u0000\u0c82\u0c83\u0001\u0000\u0000\u0000"+ - "\u0c83\u0c84\u0001\u0000\u0000\u0000\u0c84\u0c86\u0003\u01dc\u00ee\u0000"+ - "\u0c85\u0c87\u0007\u0001\u0000\u0000\u0c86\u0c85\u0001\u0000\u0000\u0000"+ - "\u0c86\u0c87\u0001\u0000\u0000\u0000\u0c87\u00e3\u0001\u0000\u0000\u0000"+ - "\u0c88\u0c89\u0005\u00bc\u0000\u0000\u0c89\u0c8a\u0005\u02bc\u0000\u0000"+ - "\u0c8a\u0c8d\u0005\u0255\u0000\u0000\u0c8b\u0c8c\u0005\u02b4\u0000\u0000"+ - "\u0c8c\u0c8e\u0005\u00d3\u0000\u0000\u0c8d\u0c8b\u0001\u0000\u0000\u0000"+ - "\u0c8d\u0c8e\u0001\u0000\u0000\u0000\u0c8e\u0c8f\u0001\u0000\u0000\u0000"+ - "\u0c8f\u0c91\u0003\u0210\u0108\u0000\u0c90\u0c92\u0007\u0001\u0000\u0000"+ - "\u0c91\u0c90\u0001\u0000\u0000\u0000\u0c91\u0c92\u0001\u0000\u0000\u0000"+ - "\u0c92\u00e5\u0001\u0000\u0000\u0000\u0c93\u0c94\u0005\u00bc\u0000\u0000"+ - "\u0c94\u0c97\u0005\u00d7\u0000\u0000\u0c95\u0c96\u0005\u02b4\u0000\u0000"+ - "\u0c96\u0c98\u0005\u00d3\u0000\u0000\u0c97\u0c95\u0001\u0000\u0000\u0000"+ - "\u0c97\u0c98\u0001\u0000\u0000\u0000\u0c98\u0c99\u0001\u0000\u0000\u0000"+ - "\u0c99\u0c9b\u0003\u01dc\u00ee\u0000\u0c9a\u0c9c\u0007\u0001\u0000\u0000"+ - "\u0c9b\u0c9a\u0001\u0000\u0000\u0000\u0c9b\u0c9c\u0001\u0000\u0000\u0000"+ - "\u0c9c\u00e7\u0001\u0000\u0000\u0000\u0c9d\u0c9e\u0005\u00bc\u0000\u0000"+ - "\u0c9e\u0c9f\u0005\u00e5\u0000\u0000\u0c9f\u0ca0\u0005\u0091\u0000\u0000"+ - "\u0ca0\u0ca3\u0005\u02bd\u0000\u0000\u0ca1\u0ca2\u0005\u02b4\u0000\u0000"+ - "\u0ca2\u0ca4\u0005\u00d3\u0000\u0000\u0ca3\u0ca1\u0001\u0000\u0000\u0000"+ - "\u0ca3\u0ca4\u0001\u0000\u0000\u0000\u0ca4\u0ca5\u0001\u0000\u0000\u0000"+ - "\u0ca5\u0ca7\u0003\u01dc\u00ee\u0000\u0ca6\u0ca8\u0007\u0001\u0000\u0000"+ - "\u0ca7\u0ca6\u0001\u0000\u0000\u0000\u0ca7\u0ca8\u0001\u0000\u0000\u0000"+ - "\u0ca8\u00e9\u0001\u0000\u0000\u0000\u0ca9\u0caa\u0005\u00bc\u0000\u0000"+ - "\u0caa\u0cab\u0005\u00e5\u0000\u0000\u0cab\u0cae\u0005\u0237\u0000\u0000"+ - "\u0cac\u0cad\u0005\u02b4\u0000\u0000\u0cad\u0caf\u0005\u00d3\u0000\u0000"+ - "\u0cae\u0cac\u0001\u0000\u0000\u0000\u0cae\u0caf\u0001\u0000\u0000\u0000"+ - "\u0caf\u0cb0\u0001\u0000\u0000\u0000\u0cb0\u0cb2\u0003\u01dc\u00ee\u0000"+ - "\u0cb1\u0cb3\u0007\u0001\u0000\u0000\u0cb2\u0cb1\u0001\u0000\u0000\u0000"+ - "\u0cb2\u0cb3\u0001\u0000\u0000\u0000\u0cb3\u00eb\u0001\u0000\u0000\u0000"+ - "\u0cb4\u0cb5\u0005\u00bc\u0000\u0000\u0cb5\u0cb8\u0005\u00ee\u0000\u0000"+ - "\u0cb6\u0cb7\u0005\u02b4\u0000\u0000\u0cb7\u0cb9\u0005\u00d3\u0000\u0000"+ - "\u0cb8\u0cb6\u0001\u0000\u0000\u0000\u0cb8\u0cb9\u0001\u0000\u0000\u0000"+ - "\u0cb9\u0cba\u0001\u0000\u0000\u0000\u0cba\u0cbc\u0003\u01ce\u00e7\u0000"+ - "\u0cbb\u0cbd\u0007\u0001\u0000\u0000\u0cbc\u0cbb\u0001\u0000\u0000\u0000"+ - "\u0cbc\u0cbd\u0001\u0000\u0000\u0000\u0cbd\u00ed\u0001\u0000\u0000\u0000"+ - "\u0cbe\u0cbf\u0005\u00bc\u0000\u0000\u0cbf\u0cc2\u0005\u00fa\u0000\u0000"+ - "\u0cc0\u0cc1\u0005\u02b4\u0000\u0000\u0cc1\u0cc3\u0005\u00d3\u0000\u0000"+ - "\u0cc2\u0cc0\u0001\u0000\u0000\u0000\u0cc2\u0cc3\u0001\u0000\u0000\u0000"+ - "\u0cc3\u0cc4\u0001\u0000\u0000\u0000\u0cc4\u0cc5\u0003\u01dc\u00ee\u0000"+ - "\u0cc5\u00ef\u0001\u0000\u0000\u0000\u0cc6\u0cc7\u0005\u00bc\u0000\u0000"+ - "\u0cc7\u0cc9\u0005\u010c\u0000\u0000\u0cc8\u0cca\u0005\u02c5\u0000\u0000"+ - "\u0cc9\u0cc8\u0001\u0000\u0000\u0000\u0cc9\u0cca\u0001\u0000\u0000\u0000"+ - "\u0cca\u0ccd\u0001\u0000\u0000\u0000\u0ccb\u0ccc\u0005\u02b4\u0000\u0000"+ - "\u0ccc\u0cce\u0005\u00d3\u0000\u0000\u0ccd\u0ccb\u0001\u0000\u0000\u0000"+ - "\u0ccd\u0cce\u0001\u0000\u0000\u0000\u0cce\u0ccf\u0001\u0000\u0000\u0000"+ - "\u0ccf\u0cd1\u0003\u01da\u00ed\u0000\u0cd0\u0cd2\u0007\u0001\u0000\u0000"+ - "\u0cd1\u0cd0\u0001\u0000\u0000\u0000\u0cd1\u0cd2\u0001\u0000\u0000\u0000"+ - "\u0cd2\u00f1\u0001\u0000\u0000\u0000\u0cd3\u0cd5\u0005\u00bc\u0000\u0000"+ - "\u0cd4\u0cd6\u0005\u01b7\u0000\u0000\u0cd5\u0cd4\u0001\u0000\u0000\u0000"+ - "\u0cd5\u0cd6\u0001\u0000\u0000\u0000\u0cd6\u0cd7\u0001\u0000\u0000\u0000"+ - "\u0cd7\u0cda\u0005\u012b\u0000\u0000\u0cd8\u0cd9\u0005\u02b4\u0000\u0000"+ - "\u0cd9\u0cdb\u0005\u00d3\u0000\u0000\u0cda\u0cd8\u0001\u0000\u0000\u0000"+ - "\u0cda\u0cdb\u0001\u0000\u0000\u0000\u0cdb\u0cdc\u0001\u0000\u0000\u0000"+ - "\u0cdc\u0cde\u0003\u0210\u0108\u0000\u0cdd\u0cdf\u0007\u0001\u0000\u0000"+ - "\u0cde\u0cdd\u0001\u0000\u0000\u0000\u0cde\u0cdf\u0001\u0000\u0000\u0000"+ - "\u0cdf\u00f3\u0001\u0000\u0000\u0000\u0ce0\u0ce1\u0005\u00bc\u0000\u0000"+ - "\u0ce1\u0ce2\u0005\u02c7\u0000\u0000\u0ce2\u0ce5\u0005\u0281\u0000\u0000"+ - "\u0ce3\u0ce4\u0005\u02b4\u0000\u0000\u0ce4\u0ce6\u0005\u00d3\u0000\u0000"+ - "\u0ce5\u0ce3\u0001\u0000\u0000\u0000\u0ce5\u0ce6\u0001\u0000\u0000\u0000"+ - "\u0ce6\u0ce7\u0001\u0000\u0000\u0000\u0ce7\u0ce9\u0003\u01dc\u00ee\u0000"+ - "\u0ce8\u0cea\u0007\u0001\u0000\u0000\u0ce9\u0ce8\u0001\u0000\u0000\u0000"+ - "\u0ce9\u0cea\u0001\u0000\u0000\u0000\u0cea\u00f5\u0001\u0000\u0000\u0000"+ - "\u0ceb\u0cec\u0003\u0214\u010a\u0000\u0cec\u00f7\u0001\u0000\u0000\u0000"+ - "\u0ced\u0cee\u0005\u00bc\u0000\u0000\u0cee\u0cef\u0005\u0184\u0000\u0000"+ - "\u0cef\u0cf2\u0005Q\u0000\u0000\u0cf0\u0cf1\u0005\u02b4\u0000\u0000\u0cf1"+ - "\u0cf3\u0005\u00d3\u0000\u0000\u0cf2\u0cf0\u0001\u0000\u0000\u0000\u0cf2"+ - "\u0cf3\u0001\u0000\u0000\u0000\u0cf3\u0cf4\u0001\u0000\u0000\u0000\u0cf4"+ - "\u0cf5\u0003\u0210\u0108\u0000\u0cf5\u0cf6\u0005\u0273\u0000\u0000\u0cf6"+ - "\u0cf8\u0003\u01e8\u00f4\u0000\u0cf7\u0cf9\u0007\u0001\u0000\u0000\u0cf8"+ - "\u0cf7\u0001\u0000\u0000\u0000\u0cf8\u0cf9\u0001\u0000\u0000\u0000\u0cf9"+ - "\u00f9\u0001\u0000\u0000\u0000\u0cfa\u0cfb\u0005\u00bc\u0000\u0000\u0cfb"+ - "\u0cfc\u0005\u0184\u0000\u0000\u0cfc\u0cff\u0005\u02ce\u0000\u0000\u0cfd"+ - "\u0cfe\u0005\u02b4\u0000\u0000\u0cfe\u0d00\u0005\u00d3\u0000\u0000\u0cff"+ - "\u0cfd\u0001\u0000\u0000\u0000\u0cff\u0d00\u0001\u0000\u0000\u0000\u0d00"+ - "\u0d01\u0001\u0000\u0000\u0000\u0d01\u0d02\u0003\u0210\u0108\u0000\u0d02"+ - "\u0d03\u0005\u0273\u0000\u0000\u0d03\u0d05\u0003\u01e8\u00f4\u0000\u0d04"+ - "\u0d06\u0007\u0001\u0000\u0000\u0d05\u0d04\u0001\u0000\u0000\u0000\u0d05"+ - "\u0d06\u0001\u0000\u0000\u0000\u0d06\u00fb\u0001\u0000\u0000\u0000\u0d07"+ - "\u0d08\u0005\u00bc\u0000\u0000\u0d08\u0d09\u0005\u02d0\u0000\u0000\u0d09"+ - "\u0d0a\u00056\u0000\u0000\u0d0a\u0d0c\u0003\u0208\u0104\u0000\u0d0b\u0d0d"+ - "\u0007\u0001\u0000\u0000\u0d0c\u0d0b\u0001\u0000\u0000\u0000\u0d0c\u0d0d"+ - "\u0001\u0000\u0000\u0000\u0d0d\u00fd\u0001\u0000\u0000\u0000\u0d0e\u0d0f"+ - "\u0005\u00bc\u0000\u0000\u0d0f\u0d12\u0005\u02cf\u0000\u0000\u0d10\u0d11"+ - "\u0005\u02b4\u0000\u0000\u0d11\u0d13\u0005\u00d3\u0000\u0000\u0d12\u0d10"+ - "\u0001\u0000\u0000\u0000\u0d12\u0d13\u0001\u0000\u0000\u0000\u0d13\u0d14"+ - "\u0001\u0000\u0000\u0000\u0d14\u0d15\u0003\u0210\u0108\u0000\u0d15\u0d16"+ - "\u0005\u0180\u0000\u0000\u0d16\u0d18\u0003\u0210\u0108\u0000\u0d17\u0d19"+ - "\u0007\u0001\u0000\u0000\u0d18\u0d17\u0001\u0000\u0000\u0000\u0d18\u0d19"+ - "\u0001\u0000\u0000\u0000\u0d19\u00ff\u0001\u0000\u0000\u0000\u0d1a\u0d1b"+ - "\u0005\u00bc\u0000\u0000\u0d1b\u0d1e\u0005\u01ba\u0000\u0000\u0d1c\u0d1d"+ - "\u0005\u02b4\u0000\u0000\u0d1d\u0d1f\u0005\u00d3\u0000\u0000\u0d1e\u0d1c"+ - "\u0001\u0000\u0000\u0000\u0d1e\u0d1f\u0001\u0000\u0000\u0000\u0d1f\u0d20"+ - "\u0001\u0000\u0000\u0000\u0d20\u0d22\u0003\u01dc\u00ee\u0000\u0d21\u0d23"+ - "\u0007\u0001\u0000\u0000\u0d22\u0d21\u0001\u0000\u0000\u0000\u0d22\u0d23"+ - "\u0001\u0000\u0000\u0000\u0d23\u0101\u0001\u0000\u0000\u0000\u0d24\u0d25"+ - "\u0005\u00bc\u0000\u0000\u0d25\u0d28\u0005\u01e5\u0000\u0000\u0d26\u0d27"+ - "\u0005\u02b4\u0000\u0000\u0d27\u0d29\u0005\u00d3\u0000\u0000\u0d28\u0d26"+ - "\u0001\u0000\u0000\u0000\u0d28\u0d29\u0001\u0000\u0000\u0000\u0d29\u0d2a"+ - "\u0001\u0000\u0000\u0000\u0d2a\u0d2b\u0003\u01dc\u00ee\u0000\u0d2b\u0103"+ - "\u0001\u0000\u0000\u0000\u0d2c\u0d2d\u0005\u00bc\u0000\u0000\u0d2d\u0d30"+ - "\u0005\u01f0\u0000\u0000\u0d2e\u0d2f\u0005\u02b4\u0000\u0000\u0d2f\u0d31"+ - "\u0005\u00d3\u0000\u0000\u0d30\u0d2e\u0001\u0000\u0000\u0000\u0d30\u0d31"+ - "\u0001\u0000\u0000\u0000\u0d31\u0d32\u0001\u0000\u0000\u0000\u0d32\u0d33"+ - "\u0003\u01d8\u00ec\u0000\u0d33\u0d34\u0005\u0180\u0000\u0000\u0d34\u0d36"+ - "\u0003\u0210\u0108\u0000\u0d35\u0d37\u0007\u0001\u0000\u0000\u0d36\u0d35"+ - "\u0001\u0000\u0000\u0000\u0d36\u0d37\u0001\u0000\u0000\u0000\u0d37\u0105"+ - "\u0001\u0000\u0000\u0000\u0d38\u0d39\u0005\u00bc\u0000\u0000\u0d39\u0d3c"+ - "\u0005\u01f3\u0000\u0000\u0d3a\u0d3b\u0005\u02b4\u0000\u0000\u0d3b\u0d3d"+ - "\u0005\u00d3\u0000\u0000\u0d3c\u0d3a\u0001\u0000\u0000\u0000\u0d3c\u0d3d"+ - "\u0001\u0000\u0000\u0000\u0d3d\u0d3e\u0001\u0000\u0000\u0000\u0d3e\u0d40"+ - "\u0003\u01dc\u00ee\u0000\u0d3f\u0d41\u0007\u0001\u0000\u0000\u0d40\u0d3f"+ - "\u0001\u0000\u0000\u0000\u0d40\u0d41\u0001\u0000\u0000\u0000\u0d41\u0107"+ - "\u0001\u0000\u0000\u0000\u0d42\u0d43\u0005\u00bc\u0000\u0000\u0d43\u0d46"+ - "\u0005\u0201\u0000\u0000\u0d44\u0d45\u0005\u02b4\u0000\u0000\u0d45\u0d47"+ - "\u0005\u00d3\u0000\u0000\u0d46\u0d44\u0001\u0000\u0000\u0000\u0d46\u0d47"+ - "\u0001\u0000\u0000\u0000\u0d47\u0d48\u0001\u0000\u0000\u0000\u0d48\u0d4a"+ - "\u0003\u01dc\u00ee\u0000\u0d49\u0d4b\u0007\u0001\u0000\u0000\u0d4a\u0d49"+ - "\u0001\u0000\u0000\u0000\u0d4a\u0d4b\u0001\u0000\u0000\u0000\u0d4b\u0109"+ - "\u0001\u0000\u0000\u0000\u0d4c\u0d4d\u0005\u00bc\u0000\u0000\u0d4d\u0d50"+ - "\u0005\u02be\u0000\u0000\u0d4e\u0d4f\u0005\u02b4\u0000\u0000\u0d4f\u0d51"+ - "\u0005\u00d3\u0000\u0000\u0d50\u0d4e\u0001\u0000\u0000\u0000\u0d50\u0d51"+ - "\u0001\u0000\u0000\u0000\u0d51\u0d52\u0001\u0000\u0000\u0000\u0d52\u0d54"+ - "\u0003\u01dc\u00ee\u0000\u0d53\u0d55\u0007\u0001\u0000\u0000\u0d54\u0d53"+ - "\u0001\u0000\u0000\u0000\u0d54\u0d55\u0001\u0000\u0000\u0000\u0d55\u010b"+ - "\u0001\u0000\u0000\u0000\u0d56\u0d57\u0005\u00bc\u0000\u0000\u0d57\u0d5a"+ - "\u0005\u0224\u0000\u0000\u0d58\u0d59\u0005\u02b4\u0000\u0000\u0d59\u0d5b"+ - "\u0005\u00d3\u0000\u0000\u0d5a\u0d58\u0001\u0000\u0000\u0000\u0d5a\u0d5b"+ - "\u0001\u0000\u0000\u0000\u0d5b\u0d5c\u0001\u0000\u0000\u0000\u0d5c\u0d5d"+ - "\u0003\u01dc\u00ee\u0000\u0d5d\u010d\u0001\u0000\u0000\u0000\u0d5e\u0d5f"+ - "\u0005\u00bc\u0000\u0000\u0d5f\u0d62\u0005\u0230\u0000\u0000\u0d60\u0d61"+ - "\u0005\u02b4\u0000\u0000\u0d61\u0d63\u0005\u00d3\u0000\u0000\u0d62\u0d60"+ - "\u0001\u0000\u0000\u0000\u0d62\u0d63\u0001\u0000\u0000\u0000\u0d63\u0d64"+ - "\u0001\u0000\u0000\u0000\u0d64\u0d66\u0003\u0210\u0108\u0000\u0d65\u0d67"+ - "\u0007\u0001\u0000\u0000\u0d66\u0d65\u0001\u0000\u0000\u0000\u0d66\u0d67"+ - "\u0001\u0000\u0000\u0000\u0d67\u010f\u0001\u0000\u0000\u0000\u0d68\u0d69"+ - "\u0005\u00bc\u0000\u0000\u0d69\u0d6c\u0005\u0237\u0000\u0000\u0d6a\u0d6b"+ - "\u0005\u02b4\u0000\u0000\u0d6b\u0d6d\u0005\u00d3\u0000\u0000\u0d6c\u0d6a"+ - "\u0001\u0000\u0000\u0000\u0d6c\u0d6d\u0001\u0000\u0000\u0000\u0d6d\u0d6e"+ - "\u0001\u0000\u0000\u0000\u0d6e\u0d70\u0003\u01dc\u00ee\u0000\u0d6f\u0d71"+ - "\u0007\u0001\u0000\u0000\u0d70\u0d6f\u0001\u0000\u0000\u0000\u0d70\u0d71"+ - "\u0001\u0000\u0000\u0000\u0d71\u0111\u0001\u0000\u0000\u0000\u0d72\u0d73"+ - "\u0005\u00bc\u0000\u0000\u0d73\u0d76\u0005\u023a\u0000\u0000\u0d74\u0d75"+ - "\u0005\u02b4\u0000\u0000\u0d75\u0d77\u0005\u00d3\u0000\u0000\u0d76\u0d74"+ - "\u0001\u0000\u0000\u0000\u0d76\u0d77\u0001\u0000\u0000\u0000\u0d77\u0d78"+ - "\u0001\u0000\u0000\u0000\u0d78\u0d79\u0003\u0210\u0108\u0000\u0d79\u0113"+ - "\u0001\u0000\u0000\u0000\u0d7a\u0d7b\u0005\u00bc\u0000\u0000\u0d7b\u0d7c"+ - "\u0005\u02f1\u0000\u0000\u0d7c\u0d7d\u0005\u01fa\u0000\u0000\u0d7d\u0d80"+ - "\u0005h\u0000\u0000\u0d7e\u0d7f\u0005\u02b4\u0000\u0000\u0d7f\u0d81\u0005"+ - "\u00d3\u0000\u0000\u0d80\u0d7e\u0001\u0000\u0000\u0000\u0d80\u0d81\u0001"+ - "\u0000\u0000\u0000\u0d81\u0d82\u0001\u0000\u0000\u0000\u0d82\u0d84\u0003"+ - "\u0210\u0108\u0000\u0d83\u0d85\u0007\u0001\u0000\u0000\u0d84\u0d83\u0001"+ - "\u0000\u0000\u0000\u0d84\u0d85\u0001\u0000\u0000\u0000\u0d85\u0115\u0001"+ - "\u0000\u0000\u0000\u0d86\u0d87\u0005\u00bc\u0000\u0000\u0d87\u0d88\u0005"+ - "\u02f1\u0000\u0000\u0d88\u0d89\u0005\u01fa\u0000\u0000\u0d89\u0d8c\u0005"+ - "\u00b2\u0000\u0000\u0d8a\u0d8b\u0005\u02b4\u0000\u0000\u0d8b\u0d8d\u0005"+ - "\u00d3\u0000\u0000\u0d8c\u0d8a\u0001\u0000\u0000\u0000\u0d8c\u0d8d\u0001"+ - "\u0000\u0000\u0000\u0d8d\u0d8e\u0001\u0000\u0000\u0000\u0d8e\u0d90\u0003"+ - "\u0210\u0108\u0000\u0d8f\u0d91\u0007\u0001\u0000\u0000\u0d90\u0d8f\u0001"+ - "\u0000\u0000\u0000\u0d90\u0d91\u0001\u0000\u0000\u0000\u0d91\u0117\u0001"+ - "\u0000\u0000\u0000\u0d92\u0d93\u0005\u00bc\u0000\u0000\u0d93\u0d94\u0005"+ - "\u02f1\u0000\u0000\u0d94\u0d95\u0005\u01fa\u0000\u0000\u0d95\u0d98\u0005"+ - "\u019d\u0000\u0000\u0d96\u0d97\u0005\u02b4\u0000\u0000\u0d97\u0d99\u0005"+ - "\u00d3\u0000\u0000\u0d98\u0d96\u0001\u0000\u0000\u0000\u0d98\u0d99\u0001"+ - "\u0000\u0000\u0000\u0d99\u0d9a\u0001\u0000\u0000\u0000\u0d9a\u0d9c\u0003"+ - "\u0210\u0108\u0000\u0d9b\u0d9d\u0007\u0001\u0000\u0000\u0d9c\u0d9b\u0001"+ - "\u0000\u0000\u0000\u0d9c\u0d9d\u0001\u0000\u0000\u0000\u0d9d\u0119\u0001"+ - "\u0000\u0000\u0000\u0d9e\u0d9f\u0005\u00bc\u0000\u0000\u0d9f\u0da0\u0005"+ - "\u02f1\u0000\u0000\u0da0\u0da1\u0005\u01fa\u0000\u0000\u0da1\u0da4\u0005"+ - "\u023c\u0000\u0000\u0da2\u0da3\u0005\u02b4\u0000\u0000\u0da3\u0da5\u0005"+ - "\u00d3\u0000\u0000\u0da4\u0da2\u0001\u0000\u0000\u0000\u0da4\u0da5\u0001"+ - "\u0000\u0000\u0000\u0da5\u0da6\u0001\u0000\u0000\u0000\u0da6\u0da8\u0003"+ - "\u0210\u0108\u0000\u0da7\u0da9\u0007\u0001\u0000\u0000\u0da8\u0da7\u0001"+ - "\u0000\u0000\u0000\u0da8\u0da9\u0001\u0000\u0000\u0000\u0da9\u011b\u0001"+ - "\u0000\u0000\u0000\u0daa\u0dab\u0005\u00bc\u0000\u0000\u0dab\u0dae\u0005"+ - "\u0250\u0000\u0000\u0dac\u0dad\u0005\u02b4\u0000\u0000\u0dad\u0daf\u0005"+ - "\u00d3\u0000\u0000\u0dae\u0dac\u0001\u0000\u0000\u0000\u0dae\u0daf\u0001"+ - "\u0000\u0000\u0000\u0daf\u0db0\u0001\u0000\u0000\u0000\u0db0\u0db1\u0005"+ - "\u00e3\u0000\u0000\u0db1\u0db2\u0003\u0210\u0108\u0000\u0db2\u0db3\u0005"+ - "\u012b\u0000\u0000\u0db3\u0db4\u0003\u0210\u0108\u0000\u0db4\u0db5\u0007"+ - "\u0001\u0000\u0000\u0db5\u011d\u0001\u0000\u0000\u0000\u0db6\u0db7\u0005"+ - "\u00bc\u0000\u0000\u0db7\u0dba\u0005\u0255\u0000\u0000\u0db8\u0db9\u0005"+ - "\u02b4\u0000\u0000\u0db9\u0dbb\u0005\u00d3\u0000\u0000\u0dba\u0db8\u0001"+ - "\u0000\u0000\u0000\u0dba\u0dbb\u0001\u0000\u0000\u0000\u0dbb\u0dbc\u0001"+ - "\u0000\u0000\u0000\u0dbc\u0dbd\u0003\u0210\u0108\u0000\u0dbd\u0dbe\u0005"+ - "\u0180\u0000\u0000\u0dbe\u0dc0\u0003\u0210\u0108\u0000\u0dbf\u0dc1\u0007"+ - "\u0001\u0000\u0000\u0dc0\u0dbf\u0001\u0000\u0000\u0000\u0dc0\u0dc1\u0001"+ - "\u0000\u0000\u0000\u0dc1\u011f\u0001\u0000\u0000\u0000\u0dc2\u0dc3\u0005"+ - "\u00bc\u0000\u0000\u0dc3\u0dc6\u0005\u025d\u0000\u0000\u0dc4\u0dc5\u0005"+ - "\u02b4\u0000\u0000\u0dc5\u0dc7\u0005\u00d3\u0000\u0000\u0dc6\u0dc4\u0001"+ - "\u0000\u0000\u0000\u0dc6\u0dc7\u0001\u0000\u0000\u0000\u0dc7\u0dc8\u0001"+ - "\u0000\u0000\u0000\u0dc8\u0dca\u0003\u01dc\u00ee\u0000\u0dc9\u0dcb\u0007"+ - "\u0001\u0000\u0000\u0dca\u0dc9\u0001\u0000\u0000\u0000\u0dca\u0dcb\u0001"+ - "\u0000\u0000\u0000\u0dcb\u0121\u0001\u0000\u0000\u0000\u0dcc\u0dcd\u0005"+ - "\u00bc\u0000\u0000\u0dcd\u0dd0\u0005\u026e\u0000\u0000\u0dce\u0dcf\u0005"+ - "\u02b4\u0000\u0000\u0dcf\u0dd1\u0005\u00d3\u0000\u0000\u0dd0\u0dce\u0001"+ - "\u0000\u0000\u0000\u0dd0\u0dd1\u0001\u0000\u0000\u0000\u0dd1\u0dd2\u0001"+ - "\u0000\u0000\u0000\u0dd2\u0dd3\u0003\u01dc\u00ee\u0000\u0dd3\u0123\u0001"+ - "\u0000\u0000\u0000\u0dd4\u0dd5\u0005\u00bc\u0000\u0000\u0dd5\u0dd6\u0005"+ - "\u026e\u0000\u0000\u0dd6\u0dd9\u0005\u0145\u0000\u0000\u0dd7\u0dd8\u0005"+ - "\u02b4\u0000\u0000\u0dd8\u0dda\u0005\u00d3\u0000\u0000\u0dd9\u0dd7\u0001"+ - "\u0000\u0000\u0000\u0dd9\u0dda\u0001\u0000\u0000\u0000\u0dda\u0ddb\u0001"+ - "\u0000\u0000\u0000\u0ddb\u0de1\u0005\u00e3\u0000\u0000\u0ddc\u0de2\u0003"+ - "\u01d8\u00ec\u0000\u0ddd\u0de2\u0005\u026e\u0000\u0000\u0dde\u0de2\u0005"+ - "\u008d\u0000\u0000\u0ddf\u0de2\u0005\u0206\u0000\u0000\u0de0\u0de2\u0005"+ - "\u01b9\u0000\u0000\u0de1\u0ddc\u0001\u0000\u0000\u0000\u0de1\u0ddd\u0001"+ - "\u0000\u0000\u0000\u0de1\u0dde\u0001\u0000\u0000\u0000\u0de1\u0ddf\u0001"+ - "\u0000\u0000\u0000\u0de1\u0de0\u0001\u0000\u0000\u0000\u0de2\u0de3\u0001"+ - "\u0000\u0000\u0000\u0de3\u0de4\u0005\u02be\u0000\u0000\u0de4\u0de5\u0003"+ - "\u0210\u0108\u0000\u0de5\u0125\u0001\u0000\u0000\u0000\u0de6\u0de7\u0005"+ - "\u00bc\u0000\u0000\u0de7\u0dea\u0005\u0281\u0000\u0000\u0de8\u0de9\u0005"+ - "\u02b4\u0000\u0000\u0de9\u0deb\u0005\u00d3\u0000\u0000\u0dea\u0de8\u0001"+ - "\u0000\u0000\u0000\u0dea\u0deb\u0001\u0000\u0000\u0000\u0deb\u0dec\u0001"+ - "\u0000\u0000\u0000\u0dec\u0dee\u0003\u01dc\u00ee\u0000\u0ded\u0def\u0007"+ - "\u0001\u0000\u0000\u0dee\u0ded\u0001\u0000\u0000\u0000\u0dee\u0def\u0001"+ - "\u0000\u0000\u0000\u0def\u0127\u0001\u0000\u0000\u0000\u0df0\u0df1\u0005"+ - "\u00d1\u0000\u0000\u0df1\u0df3\u0003\u0210\u0108\u0000\u0df2\u0df4\u0003"+ - "\u01c4\u00e2\u0000\u0df3\u0df2\u0001\u0000\u0000\u0000\u0df3\u0df4\u0001"+ - "\u0000\u0000\u0000\u0df4\u0129\u0001\u0000\u0000\u0000\u0df5\u0df7\u0005"+ - "\u00d5\u0000\u0000\u0df6\u0df8\u0005\u0016\u0000\u0000\u0df7\u0df6\u0001"+ - "\u0000\u0000\u0000\u0df7\u0df8\u0001\u0000\u0000\u0000\u0df8\u0dfa\u0001"+ - "\u0000\u0000\u0000\u0df9\u0dfb\u0005\u0280\u0000\u0000\u0dfa\u0df9\u0001"+ - "\u0000\u0000\u0000\u0dfa\u0dfb\u0001\u0000\u0000\u0000\u0dfb\u0e09\u0001"+ - "\u0000\u0000\u0000\u0dfc\u0dfd\u0005\u00d5\u0000\u0000\u0dfd\u0dfe\u0005"+ - "\u0300\u0000\u0000\u0dfe\u0e03\u0003\u018e\u00c7\u0000\u0dff\u0e00\u0005"+ - "\u02fa\u0000\u0000\u0e00\u0e02\u0003\u018e\u00c7\u0000\u0e01\u0dff\u0001"+ - "\u0000\u0000\u0000\u0e02\u0e05\u0001\u0000\u0000\u0000\u0e03\u0e01\u0001"+ - "\u0000\u0000\u0000\u0e03\u0e04\u0001\u0000\u0000\u0000\u0e04\u0e06\u0001"+ - "\u0000\u0000\u0000\u0e05\u0e03\u0001\u0000\u0000\u0000\u0e06\u0e07\u0005"+ - "\u0301\u0000\u0000\u0e07\u0e09\u0001\u0000\u0000\u0000\u0e08\u0df5\u0001"+ - "\u0000\u0000\u0000\u0e08\u0dfc\u0001\u0000\u0000\u0000\u0e09\u0e13\u0001"+ - "\u0000\u0000\u0000\u0e0a\u0e14\u0003\u0158\u00ac\u0000\u0e0b\u0e14\u0003"+ - "\u0132\u0099\u0000\u0e0c\u0e14\u0003\u0174\u00ba\u0000\u0e0d\u0e14\u0003"+ - "\u00d0h\u0000\u0e0e\u0e14\u0003\u017c\u00be\u0000\u0e0f\u0e14\u0003\u0128"+ - "\u0094\u0000\u0e10\u0e14\u0003\u00ceg\u0000\u0e11\u0e14\u0003\u00b4Z\u0000"+ - "\u0e12\u0e14\u0003\u0096K\u0000\u0e13\u0e0a\u0001\u0000\u0000\u0000\u0e13"+ - "\u0e0b\u0001\u0000\u0000\u0000\u0e13\u0e0c\u0001\u0000\u0000\u0000\u0e13"+ - "\u0e0d\u0001\u0000\u0000\u0000\u0e13\u0e0e\u0001\u0000\u0000\u0000\u0e13"+ - "\u0e0f\u0001\u0000\u0000\u0000\u0e13\u0e10\u0001\u0000\u0000\u0000\u0e13"+ - "\u0e11\u0001\u0000\u0000\u0000\u0e13\u0e12\u0001\u0000\u0000\u0000\u0e14"+ - "\u012b\u0001\u0000\u0000\u0000\u0e15\u0e16\u0003\u0214\u010a\u0000\u0e16"+ - "\u012d\u0001\u0000\u0000\u0000\u0e17\u0e18\u0003\u0214\u010a\u0000\u0e18"+ - "\u012f\u0001\u0000\u0000\u0000\u0e19\u0e1a\u0003\u0214\u010a\u0000\u0e1a"+ - "\u0131\u0001\u0000\u0000\u0000\u0e1b\u0e1d\u0003\u015c\u00ae\u0000\u0e1c"+ - "\u0e1b\u0001\u0000\u0000\u0000\u0e1c\u0e1d\u0001\u0000\u0000\u0000\u0e1d"+ - "\u0e1e\u0001\u0000\u0000\u0000\u0e1e\u0e1f\u0005\u0116\u0000\u0000\u0e1f"+ - "\u0e20\u0005\u011f\u0000\u0000\u0e20\u0e23\u0003\u01e2\u00f1\u0000\u0e21"+ - "\u0e22\u0005\u001b\u0000\u0000\u0e22\u0e24\u0003\u0210\u0108\u0000\u0e23"+ - "\u0e21\u0001\u0000\u0000\u0000\u0e23\u0e24\u0001\u0000\u0000\u0000\u0e24"+ - "\u0e29\u0001\u0000\u0000\u0000\u0e25\u0e26\u0005\u0300\u0000\u0000\u0e26"+ - "\u0e27\u0003\u01da\u00ed\u0000\u0e27\u0e28\u0005\u0301\u0000\u0000\u0e28"+ - "\u0e2a\u0001\u0000\u0000\u0000\u0e29\u0e25\u0001\u0000\u0000\u0000\u0e29"+ - "\u0e2a\u0001\u0000\u0000\u0000\u0e2a\u0e30\u0001\u0000\u0000\u0000\u0e2b"+ - "\u0e2d\u0005\u0192\u0000\u0000\u0e2c\u0e2e\u0007\u0010\u0000\u0000\u0e2d"+ - "\u0e2c\u0001\u0000\u0000\u0000\u0e2d\u0e2e\u0001\u0000\u0000\u0000\u0e2e"+ - "\u0e2f\u0001\u0000\u0000\u0000\u0e2f\u0e31\u0005\u0278\u0000\u0000\u0e30"+ - "\u0e2b\u0001\u0000\u0000\u0000\u0e30\u0e31\u0001\u0000\u0000\u0000\u0e31"+ - "\u0e36\u0001\u0000\u0000\u0000\u0e32\u0e33\u0005\u009b\u0000\u0000\u0e33"+ - "\u0e37\u0005\u0279\u0000\u0000\u0e34\u0e37\u0003\u0158\u00ac\u0000\u0e35"+ - "\u0e37\u0003\u017c\u00be\u0000\u0e36\u0e32\u0001\u0000\u0000\u0000\u0e36"+ - "\u0e34\u0001\u0000\u0000\u0000\u0e36\u0e35\u0001\u0000\u0000\u0000\u0e37"+ - "\u0e53\u0001\u0000\u0000\u0000\u0e38\u0e39\u0005\u0180\u0000\u0000\u0e39"+ - "\u0e3e\u0005i\u0000\u0000\u0e3a\u0e3b\u0005\u0300\u0000\u0000\u0e3b\u0e3c"+ - "\u0003\u0218\u010c\u0000\u0e3c\u0e3d\u0005\u0301\u0000\u0000\u0e3d\u0e3f"+ - "\u0001\u0000\u0000\u0000\u0e3e\u0e3a\u0001\u0000\u0000\u0000\u0e3e\u0e3f"+ - "\u0001\u0000\u0000\u0000\u0e3f\u0e43\u0001\u0000\u0000\u0000\u0e40\u0e41"+ - "\u0005\u0180\u0000\u0000\u0e41\u0e42\u0005m\u0000\u0000\u0e42\u0e44\u0003"+ - "\u0218\u010c\u0000\u0e43\u0e40\u0001\u0000\u0000\u0000\u0e43\u0e44\u0001"+ - "\u0000\u0000\u0000\u0e44\u0e46\u0001\u0000\u0000\u0000\u0e45\u0e47\u0003"+ - "\u0182\u00c1\u0000\u0e46\u0e45\u0001\u0000\u0000\u0000\u0e46\u0e47\u0001"+ - "\u0000\u0000\u0000\u0e47\u0e51\u0001\u0000\u0000\u0000\u0e48\u0e49\u0005"+ - "\u00b9\u0000\u0000\u0e49\u0e52\u0005\u016e\u0000\u0000\u0e4a\u0e4b\u0005"+ - "\u00b9\u0000\u0000\u0e4b\u0e4c\u0005\u026b\u0000\u0000\u0e4c\u0e4d\u0005"+ - "\u0207\u0000\u0000\u0e4d\u0e4f\u0003\u01b2\u00d9\u0000\u0e4e\u0e50\u0003"+ - "\u0182\u00c1\u0000\u0e4f\u0e4e\u0001\u0000\u0000\u0000\u0e4f\u0e50\u0001"+ - "\u0000\u0000\u0000\u0e50\u0e52\u0001\u0000\u0000\u0000\u0e51\u0e48\u0001"+ - "\u0000\u0000\u0000\u0e51\u0e4a\u0001\u0000\u0000\u0000\u0e52\u0e54\u0001"+ - "\u0000\u0000\u0000\u0e53\u0e38\u0001\u0000\u0000\u0000\u0e53\u0e54\u0001"+ - "\u0000\u0000\u0000\u0e54\u0e56\u0001\u0000\u0000\u0000\u0e55\u0e57\u0003"+ - "\u01b6\u00db\u0000\u0e56\u0e55\u0001\u0000\u0000\u0000\u0e56\u0e57\u0001"+ - "\u0000\u0000\u0000\u0e57\u0133\u0001\u0000\u0000\u0000\u0e58\u0e59\u0005"+ - "\u0137\u0000\u0000\u0e59\u0e5a\u0003\u0210\u0108\u0000\u0e5a\u0135\u0001"+ - "\u0000\u0000\u0000\u0e5b\u0e5c\u0003\u0214\u010a\u0000\u0e5c\u0137\u0001"+ - "\u0000\u0000\u0000\u0e5d\u0e5f\u0005\u013f\u0000\u0000\u0e5e\u0e60\u0005"+ - "\u0237\u0000\u0000\u0e5f\u0e5e\u0001\u0000\u0000\u0000\u0e5f\u0e60\u0001"+ - "\u0000\u0000\u0000\u0e60\u0e62\u0001\u0000\u0000\u0000\u0e61\u0e63\u0005"+ - "\u0181\u0000\u0000\u0e62\u0e61\u0001\u0000\u0000\u0000\u0e62\u0e63\u0001"+ - "\u0000\u0000\u0000\u0e63\u0e64\u0001\u0000\u0000\u0000\u0e64\u0e66\u0003"+ - "\u01d8\u00ec\u0000\u0e65\u0e67\u0005\u02ff\u0000\u0000\u0e66\u0e65\u0001"+ - "\u0000\u0000\u0000\u0e66\u0e67\u0001\u0000\u0000\u0000\u0e67\u0e7c\u0001"+ - "\u0000\u0000\u0000\u0e68\u0e79\u0005\u0109\u0000\u0000\u0e69\u0e6a\u0005"+ - "\b\u0000\u0000\u0e6a\u0e7a\u0005\u020a\u0000\u0000\u0e6b\u0e6c\u0005\u01ec"+ - "\u0000\u0000\u0e6c\u0e7a\u0005\u020a\u0000\u0000\u0e6d\u0e6e\u0005\u01ec"+ - "\u0000\u0000\u0e6e\u0e7a\u0005\u00cf\u0000\u0000\u0e6f\u0e70\u0005\u020a"+ - "\u0000\u0000\u0e70\u0e71\u0005\u026b\u0000\u0000\u0e71\u0e7a\u0005\u00cf"+ - "\u0000\u0000\u0e72\u0e7a\u0005\u020a\u0000\u0000\u0e73\u0e74\u0005\u020a"+ - "\u0000\u0000\u0e74\u0e75\u0005\u01ec\u0000\u0000\u0e75\u0e7a\u0005\u00cf"+ - "\u0000\u0000\u0e76\u0e7a\u0005\u00cf\u0000\u0000\u0e77\u0e78\u0005\b\u0000"+ - "\u0000\u0e78\u0e7a\u0005\u00cf\u0000\u0000\u0e79\u0e69\u0001\u0000\u0000"+ - "\u0000\u0e79\u0e6b\u0001\u0000\u0000\u0000\u0e79\u0e6d\u0001\u0000\u0000"+ - "\u0000\u0e79\u0e6f\u0001\u0000\u0000\u0000\u0e79\u0e72\u0001\u0000\u0000"+ - "\u0000\u0e79\u0e73\u0001\u0000\u0000\u0000\u0e79\u0e76\u0001\u0000\u0000"+ - "\u0000\u0e79\u0e77\u0001\u0000\u0000\u0000\u0e7a\u0e7b\u0001\u0000\u0000"+ - "\u0000\u0e7b\u0e7d\u0005\u0155\u0000\u0000\u0e7c\u0e68\u0001\u0000\u0000"+ - "\u0000\u0e7c\u0e7d\u0001\u0000\u0000\u0000\u0e7d\u0e7f\u0001\u0000\u0000"+ - "\u0000\u0e7e\u0e80\u0005\u0171\u0000\u0000\u0e7f\u0e7e\u0001\u0000\u0000"+ - "\u0000\u0e7f\u0e80\u0001\u0000\u0000\u0000\u0e80\u0139\u0001\u0000\u0000"+ - "\u0000\u0e81\u0e9b\u0005\u015b\u0000\u0000\u0e82\u0e97\u0005\u0166\u0000"+ - "\u0000\u0e83\u0e97\u0005\u01b5\u0000\u0000\u0e84\u0e97\u0005\u00df\u0000"+ - "\u0000\u0e85\u0e97\u0005\u012d\u0000\u0000\u0e86\u0e87\u0005\u0007\u0000"+ - "\u0000\u0e87\u0e97\u0005\u011b\u0000\u0000\u0e88\u0e89\u0005\u01d2\u0000"+ - "\u0000\u0e89\u0e97\u0003\u01bc\u00de\u0000\u0e8a\u0e97\u0003\u01bc\u00de"+ - "\u0000\u0e8b\u0e97\u0005\u0010\u0000\u0000\u0e8c\u0e8f\u0005\u00e8\u0000"+ - "\u0000\u0e8d\u0e90\u0003\u01bc\u00de\u0000\u0e8e\u0e90\u0005\u0010\u0000"+ - "\u0000\u0e8f\u0e8d\u0001\u0000\u0000\u0000\u0e8f\u0e8e\u0001\u0000\u0000"+ - "\u0000\u0e8f\u0e90\u0001\u0000\u0000\u0000\u0e90\u0e97\u0001\u0000\u0000"+ - "\u0000\u0e91\u0e94\u0005\'\u0000\u0000\u0e92\u0e95\u0003\u01bc\u00de\u0000"+ - "\u0e93\u0e95\u0005\u0010\u0000\u0000\u0e94\u0e92\u0001\u0000\u0000\u0000"+ - "\u0e94\u0e93\u0001\u0000\u0000\u0000\u0e94\u0e95\u0001\u0000\u0000\u0000"+ - "\u0e95\u0e97\u0001\u0000\u0000\u0000\u0e96\u0e82\u0001\u0000\u0000\u0000"+ - "\u0e96\u0e83\u0001\u0000\u0000\u0000\u0e96\u0e84\u0001\u0000\u0000\u0000"+ - "\u0e96\u0e85\u0001\u0000\u0000\u0000\u0e96\u0e86\u0001\u0000\u0000\u0000"+ - "\u0e96\u0e88\u0001\u0000\u0000\u0000\u0e96\u0e8a\u0001\u0000\u0000\u0000"+ - "\u0e96\u0e8b\u0001\u0000\u0000\u0000\u0e96\u0e8c\u0001\u0000\u0000\u0000"+ - "\u0e96\u0e91\u0001\u0000\u0000\u0000\u0e97\u0e99\u0001\u0000\u0000\u0000"+ - "\u0e98\u0e9a\u0007\u0011\u0000\u0000\u0e99\u0e98\u0001\u0000\u0000\u0000"+ - "\u0e99\u0e9a\u0001\u0000\u0000\u0000\u0e9a\u0e9c\u0001\u0000\u0000\u0000"+ - "\u0e9b\u0e96\u0001\u0000\u0000\u0000\u0e9b\u0e9c\u0001\u0000\u0000\u0000"+ - "\u0e9c\u0e9d\u0001\u0000\u0000\u0000\u0e9d\u0e9e\u0003\u01d8\u00ec\u0000"+ - "\u0e9e\u013b\u0001\u0000\u0000\u0000\u0e9f\u0ea0\u0005\u016f\u0000\u0000"+ - "\u0ea0\u0ea3\u0003\u01d8\u00ec\u0000\u0ea1\u0ea2\u0005\u02fa\u0000\u0000"+ - "\u0ea2\u0ea4\u0005\u030a\u0000\u0000\u0ea3\u0ea1\u0001\u0000\u0000\u0000"+ - "\u0ea3\u0ea4\u0001\u0000\u0000\u0000\u0ea4\u013d\u0001\u0000\u0000\u0000"+ - "\u0ea5\u0ea6\u0005\u01b1\u0000\u0000\u0ea6\u0eab\u0003\u0210\u0108\u0000"+ - "\u0ea7\u0ea8\u0005\u0300\u0000\u0000\u0ea8\u0ea9\u0003\u01e6\u00f3\u0000"+ - "\u0ea9\u0eaa\u0005\u0301\u0000\u0000\u0eaa\u0eac\u0001\u0000\u0000\u0000"+ - "\u0eab\u0ea7\u0001\u0000\u0000\u0000\u0eab\u0eac\u0001\u0000\u0000\u0000"+ - "\u0eac\u0ead\u0001\u0000\u0000\u0000\u0ead\u0eb3\u0005\u001b\u0000\u0000"+ - "\u0eae\u0eb4\u0003\u0158\u00ac\u0000\u0eaf\u0eb4\u0003\u0132\u0099\u0000"+ - "\u0eb0\u0eb4\u0003\u0174\u00ba\u0000\u0eb1\u0eb4\u0003\u00d0h\u0000\u0eb2"+ - "\u0eb4\u0003\u017c\u00be\u0000\u0eb3\u0eae\u0001\u0000\u0000\u0000\u0eb3"+ - "\u0eaf\u0001\u0000\u0000\u0000\u0eb3\u0eb0\u0001\u0000\u0000\u0000\u0eb3"+ - "\u0eb1\u0001\u0000\u0000\u0000\u0eb3\u0eb2\u0001\u0000\u0000\u0000\u0eb4"+ - "\u013f\u0001\u0000\u0000\u0000\u0eb5\u0eb6\u0005\u01b1\u0000\u0000\u0eb6"+ - "\u0eb7\u0005\u024c\u0000\u0000\u0eb7\u0eb8\u0003\u01d8\u00ec\u0000\u0eb8"+ - "\u0141\u0001\u0000\u0000\u0000\u0eb9\u0eba\u0005\u01c1\u0000\u0000\u0eba"+ - "\u0ebb\u0005\u02d0\u0000\u0000\u0ebb\u0ebf\u00056\u0000\u0000\u0ebc\u0ec0"+ - "\u0003\u0210\u0108\u0000\u0ebd\u0ec0\u0005\u008d\u0000\u0000\u0ebe\u0ec0"+ - "\u0005\u0206\u0000\u0000\u0ebf\u0ebc\u0001\u0000\u0000\u0000\u0ebf\u0ebd"+ - "\u0001\u0000\u0000\u0000\u0ebf\u0ebe\u0001\u0000\u0000\u0000\u0ec0\u0ec9"+ - "\u0001\u0000\u0000\u0000\u0ec1\u0ec5\u0005\u02fa\u0000\u0000\u0ec2\u0ec6"+ - "\u0003\u0210\u0108\u0000\u0ec3\u0ec6\u0005\u008d\u0000\u0000\u0ec4\u0ec6"+ - "\u0005\u0206\u0000\u0000\u0ec5\u0ec2\u0001\u0000\u0000\u0000\u0ec5\u0ec3"+ - "\u0001\u0000\u0000\u0000\u0ec5\u0ec4\u0001\u0000\u0000\u0000\u0ec6\u0ec8"+ - "\u0001\u0000\u0000\u0000\u0ec7\u0ec1\u0001\u0000\u0000\u0000\u0ec8\u0ecb"+ - "\u0001\u0000\u0000\u0000\u0ec9\u0ec7\u0001\u0000\u0000\u0000\u0ec9\u0eca"+ - "\u0001\u0000\u0000\u0000\u0eca\u0ecc\u0001\u0000\u0000\u0000\u0ecb\u0ec9"+ - "\u0001\u0000\u0000\u0000\u0ecc\u0ed0\u0005\u0247\u0000\u0000\u0ecd\u0ed1"+ - "\u0003\u0210\u0108\u0000\u0ece\u0ed1\u0005\u008d\u0000\u0000\u0ecf\u0ed1"+ - "\u0005\u0206\u0000\u0000\u0ed0\u0ecd\u0001\u0000\u0000\u0000\u0ed0\u0ece"+ - "\u0001\u0000\u0000\u0000\u0ed0\u0ecf\u0001\u0000\u0000\u0000\u0ed1\u0143"+ - "\u0001\u0000\u0000\u0000\u0ed2\u0ed3\u0003\u0214\u010a\u0000\u0ed3\u0145"+ - "\u0001\u0000\u0000\u0000\u0ed4\u0ed8\u0005\u01d1\u0000\u0000\u0ed5\u0ed6"+ - "\u0005\u0300\u0000\u0000\u0ed6\u0ed7\u0005\u0280\u0000\u0000\u0ed7\u0ed9"+ - "\u0005\u0301\u0000\u0000\u0ed8\u0ed5\u0001\u0000\u0000\u0000\u0ed8\u0ed9"+ - "\u0001\u0000\u0000\u0000\u0ed9\u0eda\u0001\u0000\u0000\u0000\u0eda\u0edb"+ - "\u0007\u0012\u0000\u0000\u0edb\u0edc\u0003\u0210\u0108\u0000\u0edc\u0147"+ - "\u0001\u0000\u0000\u0000\u0edd\u0edf\u0005\u01d3\u0000\u0000\u0ede\u0ee0"+ - "\u0005\u01f1\u0000\u0000\u0edf\u0ede\u0001\u0000\u0000\u0000\u0edf\u0ee0"+ - "\u0001\u0000\u0000\u0000\u0ee0\u0ee1\u0001\u0000\u0000\u0000\u0ee1\u0ee2"+ - "\u0003\u0210\u0108\u0000\u0ee2\u0149\u0001\u0000\u0000\u0000\u0ee3\u0ee6"+ - "\u0005\u01d8\u0000\u0000\u0ee4\u0ee7\u0003\u0210\u0108\u0000\u0ee5\u0ee7"+ - "\u0005\u0010\u0000\u0000\u0ee6\u0ee4\u0001\u0000\u0000\u0000\u0ee6\u0ee5"+ - "\u0001\u0000\u0000\u0000\u0ee7\u014b\u0001\u0000\u0000\u0000\u0ee8\u0ee9"+ - "\u0003\u0214\u010a\u0000\u0ee9\u014d\u0001\u0000\u0000\u0000\u0eea\u0eec"+ - "\u0005\u01e6\u0000\u0000\u0eeb\u0eed\u0007\u0013\u0000\u0000\u0eec\u0eeb"+ - "\u0001\u0000\u0000\u0000\u0eec\u0eed\u0001\u0000\u0000\u0000\u0eed\u014f"+ - "\u0001\u0000\u0000\u0000\u0eee\u0eef\u0005\u01e6\u0000\u0000\u0eef\u0ef0"+ - "\u0005\u01b2\u0000\u0000\u0ef0\u0ef1\u0005\u0307\u0000\u0000\u0ef1\u0151"+ - "\u0001\u0000\u0000\u0000\u0ef2\u0ef4\u0005\u01e6\u0000\u0000\u0ef3\u0ef5"+ - "\u0007\u0013\u0000\u0000\u0ef4\u0ef3\u0001\u0000\u0000\u0000\u0ef4\u0ef5"+ - "\u0001\u0000\u0000\u0000\u0ef5\u0ef6\u0001\u0000\u0000\u0000\u0ef6\u0ef8"+ - "\u0005\u0247\u0000\u0000\u0ef7\u0ef9\u0005\u01f1\u0000\u0000\u0ef8\u0ef7"+ - "\u0001\u0000\u0000\u0000\u0ef8\u0ef9\u0001\u0000\u0000\u0000\u0ef9\u0efa"+ - "\u0001\u0000\u0000\u0000\u0efa\u0efb\u0003\u0210\u0108\u0000\u0efb\u0153"+ - "\u0001\u0000\u0000\u0000\u0efc\u0efd\u0005\u01f1\u0000\u0000\u0efd\u0efe"+ - "\u0003\u0210\u0108\u0000\u0efe\u0155\u0001\u0000\u0000\u0000\u0eff\u0f00"+ - "\u0005\u01fd\u0000\u0000\u0f00\u0f03\u0005\u0129\u0000\u0000\u0f01\u0f02"+ - "\u0005\u00e3\u0000\u0000\u0f02\u0f04\u0003\u01d8\u00ec\u0000\u0f03\u0f01"+ - "\u0001\u0000\u0000\u0000\u0f03\u0f04\u0001\u0000\u0000\u0000\u0f04\u0f05"+ - "\u0001\u0000\u0000\u0000\u0f05\u0f3c\u0005\u0180\u0000\u0000\u0f06\u0f07"+ - "\u0005\u0237\u0000\u0000\u0f07\u0f3d\u0003\u0210\u0108\u0000\u0f08\u0f09"+ - "\u0005^\u0000\u0000\u0f09\u0f0a\u0003\u0210\u0108\u0000\u0f0a\u0f0b\u0005"+ - "\u0309\u0000\u0000\u0f0b\u0f0c\u0003\u0218\u010c\u0000\u0f0c\u0f3d\u0001"+ - "\u0000\u0000\u0000\u0f0d\u0f0e\u0005\u000e\u0000\u0000\u0f0e\u0f0f\u0003"+ - "\u0210\u0108\u0000\u0f0f\u0f10\u0005\u0300\u0000\u0000\u0f10\u0f11\u0003"+ - "\u01fa\u00fd\u0000\u0f11\u0f12\u0005\u0301\u0000\u0000\u0f12\u0f3d\u0001"+ - "\u0000\u0000\u0000\u0f13\u0f14\u0005\u0092\u0000\u0000\u0f14\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f15\u0f16\u0005\u00ba\u0000\u0000\u0f16\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f17\u0f18\u0005\u02bc\u0000\u0000\u0f18\u0f19\u0005"+ - "\u0255\u0000\u0000\u0f19\u0f3d\u0003\u0210\u0108\u0000\u0f1a\u0f1b\u0005"+ - "\u00e5\u0000\u0000\u0f1b\u0f1c\u0005\u0237\u0000\u0000\u0f1c\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f1d\u0f1e\u0005\u00ee\u0000\u0000\u0f1e\u0f1f\u0003"+ - "\u0210\u0108\u0000\u0f1f\u0f20\u0003\u01cc\u00e6\u0000\u0f20\u0f3d\u0001"+ - "\u0000\u0000\u0000\u0f21\u0f22\u0005\u012c\u0000\u0000\u0f22\u0f23\u0005"+ - "\u0178\u0000\u0000\u0f23\u0f3d\u0005\u0307\u0000\u0000\u0f24\u0f25\u0005"+ - "\u02c7\u0000\u0000\u0f25\u0f26\u0005\u0281\u0000\u0000\u0f26\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f27\u0f29\u0005\u01b7\u0000\u0000\u0f28\u0f27\u0001"+ - "\u0000\u0000\u0000\u0f28\u0f29\u0001\u0000\u0000\u0000\u0f29\u0f2a\u0001"+ - "\u0000\u0000\u0000\u0f2a\u0f2b\u0005\u012b\u0000\u0000\u0f2b\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f2c\u0f2d\u0005\u01ba\u0000\u0000\u0f2d\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f2e\u0f2f\u0005\u01e5\u0000\u0000\u0f2f\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f30\u0f31\u0005\u01f3\u0000\u0000\u0f31\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f32\u0f33\u0005\u0201\u0000\u0000\u0f33\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f34\u0f35\u0005\u0230\u0000\u0000\u0f35\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f36\u0f37\u0005\u023a\u0000\u0000\u0f37\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f38\u0f39\u0005\u025d\u0000\u0000\u0f39\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f3a\u0f3b\u0005\u0281\u0000\u0000\u0f3b\u0f3d\u0003"+ - "\u0210\u0108\u0000\u0f3c\u0f06\u0001\u0000\u0000\u0000\u0f3c\u0f08\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f0d\u0001\u0000\u0000\u0000\u0f3c\u0f13\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f15\u0001\u0000\u0000\u0000\u0f3c\u0f17\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f1a\u0001\u0000\u0000\u0000\u0f3c\u0f1d\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f21\u0001\u0000\u0000\u0000\u0f3c\u0f24\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f28\u0001\u0000\u0000\u0000\u0f3c\u0f2c\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f2e\u0001\u0000\u0000\u0000\u0f3c\u0f30\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f32\u0001\u0000\u0000\u0000\u0f3c\u0f34\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f36\u0001\u0000\u0000\u0000\u0f3c\u0f38\u0001"+ - "\u0000\u0000\u0000\u0f3c\u0f3a\u0001\u0000\u0000\u0000\u0f3d\u0f3e\u0001"+ - "\u0000\u0000\u0000\u0f3e\u0f3f\u0005\u0121\u0000\u0000\u0f3f\u0f40\u0005"+ - "\u030a\u0000\u0000\u0f40\u0157\u0001\u0000\u0000\u0000\u0f41\u0f43\u0003"+ - "\u015c\u00ae\u0000\u0f42\u0f41\u0001\u0000\u0000\u0000\u0f42\u0f43\u0001"+ - "\u0000\u0000\u0000\u0f43\u0f5e\u0001\u0000\u0000\u0000\u0f44\u0f45\u0005"+ - "\u01fe\u0000\u0000\u0f45\u0f47\u0003\u017e\u00bf\u0000\u0f46\u0f48\u0003"+ - "\u0180\u00c0\u0000\u0f47\u0f46\u0001\u0000\u0000\u0000\u0f47\u0f48\u0001"+ - "\u0000\u0000\u0000\u0f48\u0f5f\u0001\u0000\u0000\u0000\u0f49\u0f4b\u0005"+ - "\u0237\u0000\u0000\u0f4a\u0f4c\u0005\u0181\u0000\u0000\u0f4b\u0f4a\u0001"+ - "\u0000\u0000\u0000\u0f4b\u0f4c\u0001\u0000\u0000\u0000\u0f4c\u0f4d\u0001"+ - "\u0000\u0000\u0000\u0f4d\u0f4f\u0003\u01e2\u00f1\u0000\u0f4e\u0f50\u0005"+ - "\u02ff\u0000\u0000\u0f4f\u0f4e\u0001\u0000\u0000\u0000\u0f4f\u0f50\u0001"+ - "\u0000\u0000\u0000\u0f50\u0f5f\u0001\u0000\u0000\u0000\u0f51\u0f53\u0005"+ - "\u0300\u0000\u0000\u0f52\u0f51\u0001\u0000\u0000\u0000\u0f53\u0f54\u0001"+ - "\u0000\u0000\u0000\u0f54\u0f52\u0001\u0000\u0000\u0000\u0f54\u0f55\u0001"+ - "\u0000\u0000\u0000\u0f55\u0f56\u0001\u0000\u0000\u0000\u0f56\u0f58\u0003"+ - "\u0158\u00ac\u0000\u0f57\u0f59\u0005\u0301\u0000\u0000\u0f58\u0f57\u0001"+ - "\u0000\u0000\u0000\u0f59\u0f5a\u0001\u0000\u0000\u0000\u0f5a\u0f58\u0001"+ - "\u0000\u0000\u0000\u0f5a\u0f5b\u0001\u0000\u0000\u0000\u0f5b\u0f5c\u0001"+ - "\u0000\u0000\u0000\u0f5c\u0f5d\u0003\u01a4\u00d2\u0000\u0f5d\u0f5f\u0001"+ - "\u0000\u0000\u0000\u0f5e\u0f44\u0001\u0000\u0000\u0000\u0f5e\u0f49\u0001"+ - "\u0000\u0000\u0000\u0f5e\u0f52\u0001\u0000\u0000\u0000\u0f5f\u0f61\u0001"+ - "\u0000\u0000\u0000\u0f60\u0f62\u0003\u0182\u00c1\u0000\u0f61\u0f60\u0001"+ - "\u0000\u0000\u0000\u0f61\u0f62\u0001\u0000\u0000\u0000\u0f62\u0f64\u0001"+ - "\u0000\u0000\u0000\u0f63\u0f65\u0003\u0184\u00c2\u0000\u0f64\u0f63\u0001"+ - "\u0000\u0000\u0000\u0f64\u0f65\u0001\u0000\u0000\u0000\u0f65\u0f67\u0001"+ - "\u0000\u0000\u0000\u0f66\u0f68\u0003\u018a\u00c5\u0000\u0f67\u0f66\u0001"+ - "\u0000\u0000\u0000\u0f67\u0f68\u0001\u0000\u0000\u0000\u0f68\u0f6a\u0001"+ - "\u0000\u0000\u0000\u0f69\u0f6b\u0003\u019c\u00ce\u0000\u0f6a\u0f69\u0001"+ - "\u0000\u0000\u0000\u0f6a\u0f6b\u0001\u0000\u0000\u0000\u0f6b\u0f6d\u0001"+ - "\u0000\u0000\u0000\u0f6c\u0f6e\u0003\u01a4\u00d2\u0000\u0f6d\u0f6c\u0001"+ - "\u0000\u0000\u0000\u0f6d\u0f6e\u0001\u0000\u0000\u0000\u0f6e\u0f70\u0001"+ - "\u0000\u0000\u0000\u0f6f\u0f71\u0003\u01a6\u00d3\u0000\u0f70\u0f6f\u0001"+ - "\u0000\u0000\u0000\u0f70\u0f71\u0001\u0000\u0000\u0000\u0f71\u0f73\u0001"+ - "\u0000\u0000\u0000\u0f72\u0f74\u0003\u01aa\u00d5\u0000\u0f73\u0f72\u0001"+ - "\u0000\u0000\u0000\u0f73\u0f74\u0001\u0000\u0000\u0000\u0f74\u0f76\u0001"+ - "\u0000\u0000\u0000\u0f75\u0f77\u0003\u01ac\u00d6\u0000\u0f76\u0f75\u0001"+ - "\u0000\u0000\u0000\u0f76\u0f77\u0001\u0000\u0000\u0000\u0f77\u0f79\u0001"+ - "\u0000\u0000\u0000\u0f78\u0f7a\u0003\u01ae\u00d7\u0000\u0f79\u0f78\u0001"+ - "\u0000\u0000\u0000\u0f79\u0f7a\u0001\u0000\u0000\u0000\u0f7a\u0f7c\u0001"+ - "\u0000\u0000\u0000\u0f7b\u0f7d\u0003\u01b0\u00d8\u0000\u0f7c\u0f7b\u0001"+ - "\u0000\u0000\u0000\u0f7c\u0f7d\u0001\u0000\u0000\u0000\u0f7d\u0159\u0001"+ - "\u0000\u0000\u0000\u0f7e\u0f80\u0003\u015c\u00ae\u0000\u0f7f\u0f7e\u0001"+ - "\u0000\u0000\u0000\u0f7f\u0f80\u0001\u0000\u0000\u0000\u0f80\u0fa3\u0001"+ - "\u0000\u0000\u0000\u0f81\u0f82\u0005\u01fe\u0000\u0000\u0f82\u0f83\u0003"+ - "\u017e\u00bf\u0000\u0f83\u0f85\u0005\u011f\u0000\u0000\u0f84\u0f86\u0007"+ - "\u0014\u0000\u0000\u0f85\u0f84\u0001\u0000\u0000\u0000\u0f85\u0f86\u0001"+ - "\u0000\u0000\u0000\u0f86\u0f88\u0001\u0000\u0000\u0000\u0f87\u0f89\u0005"+ - "\u0237\u0000\u0000\u0f88\u0f87\u0001\u0000\u0000\u0000\u0f88\u0f89\u0001"+ - "\u0000\u0000\u0000\u0f89\u0f8a\u0001\u0000\u0000\u0000\u0f8a\u0f8c\u0003"+ - "\u01e2\u00f1\u0000\u0f8b\u0f8d\u0003\u0180\u00c0\u0000\u0f8c\u0f8b\u0001"+ - "\u0000\u0000\u0000\u0f8c\u0f8d\u0001\u0000\u0000\u0000\u0f8d\u0fa4\u0001"+ - "\u0000\u0000\u0000\u0f8e\u0f90\u0005\u0237\u0000\u0000\u0f8f\u0f91\u0005"+ - "\u0181\u0000\u0000\u0f90\u0f8f\u0001\u0000\u0000\u0000\u0f90\u0f91\u0001"+ - "\u0000\u0000\u0000\u0f91\u0f92\u0001\u0000\u0000\u0000\u0f92\u0f94\u0003"+ - "\u01e2\u00f1\u0000\u0f93\u0f95\u0005\u02ff\u0000\u0000\u0f94\u0f93\u0001"+ - "\u0000\u0000\u0000\u0f94\u0f95\u0001\u0000\u0000\u0000\u0f95\u0fa4\u0001"+ - "\u0000\u0000\u0000\u0f96\u0f98\u0005\u0300\u0000\u0000\u0f97\u0f96\u0001"+ - "\u0000\u0000\u0000\u0f98\u0f99\u0001\u0000\u0000\u0000\u0f99\u0f97\u0001"+ - "\u0000\u0000\u0000\u0f99\u0f9a\u0001\u0000\u0000\u0000\u0f9a\u0f9b\u0001"+ - "\u0000\u0000\u0000\u0f9b\u0f9d\u0003\u0158\u00ac\u0000\u0f9c\u0f9e\u0005"+ - "\u0301\u0000\u0000\u0f9d\u0f9c\u0001\u0000\u0000\u0000\u0f9e\u0f9f\u0001"+ - "\u0000\u0000\u0000\u0f9f\u0f9d\u0001\u0000\u0000\u0000\u0f9f\u0fa0\u0001"+ - "\u0000\u0000\u0000\u0fa0\u0fa1\u0001\u0000\u0000\u0000\u0fa1\u0fa2\u0003"+ - "\u01a4\u00d2\u0000\u0fa2\u0fa4\u0001\u0000\u0000\u0000\u0fa3\u0f81\u0001"+ - "\u0000\u0000\u0000\u0fa3\u0f8e\u0001\u0000\u0000\u0000\u0fa3\u0f97\u0001"+ - "\u0000\u0000\u0000\u0fa4\u0fa6\u0001\u0000\u0000\u0000\u0fa5\u0fa7\u0003"+ - "\u0182\u00c1\u0000\u0fa6\u0fa5\u0001\u0000\u0000\u0000\u0fa6\u0fa7\u0001"+ - "\u0000\u0000\u0000\u0fa7\u0fa9\u0001\u0000\u0000\u0000\u0fa8\u0faa\u0003"+ - "\u0184\u00c2\u0000\u0fa9\u0fa8\u0001\u0000\u0000\u0000\u0fa9\u0faa\u0001"+ - "\u0000\u0000\u0000\u0faa\u0fac\u0001\u0000\u0000\u0000\u0fab\u0fad\u0003"+ - "\u018a\u00c5\u0000\u0fac\u0fab\u0001\u0000\u0000\u0000\u0fac\u0fad\u0001"+ - "\u0000\u0000\u0000\u0fad\u0faf\u0001\u0000\u0000\u0000\u0fae\u0fb0\u0003"+ - "\u019c\u00ce\u0000\u0faf\u0fae\u0001\u0000\u0000\u0000\u0faf\u0fb0\u0001"+ - "\u0000\u0000\u0000\u0fb0\u0fb2\u0001\u0000\u0000\u0000\u0fb1\u0fb3\u0003"+ - "\u01a4\u00d2\u0000\u0fb2\u0fb1\u0001\u0000\u0000\u0000\u0fb2\u0fb3\u0001"+ - "\u0000\u0000\u0000\u0fb3\u0fb5\u0001\u0000\u0000\u0000\u0fb4\u0fb6\u0003"+ - "\u01a6\u00d3\u0000\u0fb5\u0fb4\u0001\u0000\u0000\u0000\u0fb5\u0fb6\u0001"+ - "\u0000\u0000\u0000\u0fb6\u0fb8\u0001\u0000\u0000\u0000\u0fb7\u0fb9\u0003"+ - "\u01aa\u00d5\u0000\u0fb8\u0fb7\u0001\u0000\u0000\u0000\u0fb8\u0fb9\u0001"+ - "\u0000\u0000\u0000\u0fb9\u0fbb\u0001\u0000\u0000\u0000\u0fba\u0fbc\u0003"+ - "\u01ac\u00d6\u0000\u0fbb\u0fba\u0001\u0000\u0000\u0000\u0fbb\u0fbc\u0001"+ - "\u0000\u0000\u0000\u0fbc\u0fbe\u0001\u0000\u0000\u0000\u0fbd\u0fbf\u0003"+ - "\u01ae\u00d7\u0000\u0fbe\u0fbd\u0001\u0000\u0000\u0000\u0fbe\u0fbf\u0001"+ - "\u0000\u0000\u0000\u0fbf\u0fc1\u0001\u0000\u0000\u0000\u0fc0\u0fc2\u0003"+ - "\u01b0\u00d8\u0000\u0fc1\u0fc0\u0001\u0000\u0000\u0000\u0fc1\u0fc2\u0001"+ - "\u0000\u0000\u0000\u0fc2\u015b\u0001\u0000\u0000\u0000\u0fc3\u0fc5\u0005"+ - "\u0288\u0000\u0000\u0fc4\u0fc6\u0005\u01c3\u0000\u0000\u0fc5\u0fc4\u0001"+ - "\u0000\u0000\u0000\u0fc5\u0fc6\u0001\u0000\u0000\u0000\u0fc6\u0fc7\u0001"+ - "\u0000\u0000\u0000\u0fc7\u0fcc\u0003\u015e\u00af\u0000\u0fc8\u0fc9\u0005"+ - "\u02fa\u0000\u0000\u0fc9\u0fcb\u0003\u015e\u00af\u0000\u0fca\u0fc8\u0001"+ - "\u0000\u0000\u0000\u0fcb\u0fce\u0001\u0000\u0000\u0000\u0fcc\u0fca\u0001"+ - "\u0000\u0000\u0000\u0fcc\u0fcd\u0001\u0000\u0000\u0000\u0fcd\u015d\u0001"+ - "\u0000\u0000\u0000\u0fce\u0fcc\u0001\u0000\u0000\u0000\u0fcf\u0fd4\u0003"+ - "\u01e2\u00f1\u0000\u0fd0\u0fd1\u0005\u0300\u0000\u0000\u0fd1\u0fd2\u0003"+ - "\u01da\u00ed\u0000\u0fd2\u0fd3\u0005\u0301\u0000\u0000\u0fd3\u0fd5\u0001"+ - "\u0000\u0000\u0000\u0fd4\u0fd0\u0001\u0000\u0000\u0000\u0fd4\u0fd5\u0001"+ - "\u0000\u0000\u0000\u0fd5\u0fd6\u0001\u0000\u0000\u0000\u0fd6\u0fd7\u0005"+ - "\u001b\u0000\u0000\u0fd7\u0fdd\u0005\u0300\u0000\u0000\u0fd8\u0fde\u0003"+ - "\u0158\u00ac\u0000\u0fd9\u0fde\u0003\u0132\u0099\u0000\u0fda\u0fde\u0003"+ - "\u00d0h\u0000\u0fdb\u0fde\u0003\u0174\u00ba\u0000\u0fdc\u0fde\u0003\u017c"+ - "\u00be\u0000\u0fdd\u0fd8\u0001\u0000\u0000\u0000\u0fdd\u0fd9\u0001\u0000"+ - "\u0000\u0000\u0fdd\u0fda\u0001\u0000\u0000\u0000\u0fdd\u0fdb\u0001\u0000"+ - "\u0000\u0000\u0fdd\u0fdc\u0001\u0000\u0000\u0000\u0fde\u0fdf\u0001\u0000"+ - "\u0000\u0000\u0fdf\u0fe0\u0005\u0301\u0000\u0000\u0fe0\u015f\u0001\u0000"+ - "\u0000\u0000\u0fe1\u0fe3\u0005\u0207\u0000\u0000\u0fe2\u0fe4\u0007\u0015"+ - "\u0000\u0000\u0fe3\u0fe2\u0001\u0000\u0000\u0000\u0fe3\u0fe4\u0001\u0000"+ - "\u0000\u0000\u0fe4\u0fe5\u0001\u0000\u0000\u0000\u0fe5\u0fe6\u0003\u0210"+ - "\u0108\u0000\u0fe6\u0fe9\u0007\u0005\u0000\u0000\u0fe7\u0fea\u0003\u020a"+ - "\u0105\u0000\u0fe8\u0fea\u0005\u009b\u0000\u0000\u0fe9\u0fe7\u0001\u0000"+ - "\u0000\u0000\u0fe9\u0fe8\u0001\u0000\u0000\u0000\u0fea\u0ff7\u0001\u0000"+ - "\u0000\u0000\u0feb\u0fed\u0005\u0207\u0000\u0000\u0fec\u0fee\u0007\u0015"+ - "\u0000\u0000\u0fed\u0fec\u0001\u0000\u0000\u0000\u0fed\u0fee\u0001\u0000"+ - "\u0000\u0000\u0fee\u0fef\u0001\u0000\u0000\u0000\u0fef\u0ff0\u0005\u0242"+ - "\u0000\u0000\u0ff0\u0ff4\u0005\u0290\u0000\u0000\u0ff1\u0ff5\u0003\u01d2"+ - "\u00e9\u0000\u0ff2\u0ff5\u0005\u013a\u0000\u0000\u0ff3\u0ff5\u0005\u009b"+ - "\u0000\u0000\u0ff4\u0ff1\u0001\u0000\u0000\u0000\u0ff4\u0ff2\u0001\u0000"+ - "\u0000\u0000\u0ff4\u0ff3\u0001\u0000\u0000\u0000\u0ff5\u0ff7\u0001\u0000"+ - "\u0000\u0000\u0ff6\u0fe1\u0001\u0000\u0000\u0000\u0ff6\u0feb\u0001\u0000"+ - "\u0000\u0000\u0ff7\u0161\u0001\u0000\u0000\u0000\u0ff8\u0ff9\u0005\u0207"+ - "\u0000\u0000\u0ff9\u0ffc\u0005q\u0000\u0000\u0ffa\u0ffd\u0005\u0010\u0000"+ - "\u0000\u0ffb\u0ffd\u0003\u01dc\u00ee\u0000\u0ffc\u0ffa\u0001\u0000\u0000"+ - "\u0000\u0ffc\u0ffb\u0001\u0000\u0000\u0000\u0ffd\u0ffe\u0001\u0000\u0000"+ - "\u0000\u0ffe\u0fff\u0007\u0016\u0000\u0000\u0fff\u0163\u0001\u0000\u0000"+ - "\u0000\u1000\u1002\u0005\u0207\u0000\u0000\u1001\u1003\u0007\u0015\u0000"+ - "\u0000\u1002\u1001\u0001\u0000\u0000\u0000\u1002\u1003\u0001\u0000\u0000"+ - "\u0000\u1003\u1004\u0001\u0000\u0000\u0000\u1004\u1007\u0005\u01e5\u0000"+ - "\u0000\u1005\u1008\u0003\u0206\u0103\u0000\u1006\u1008\u0005\u016a\u0000"+ - "\u0000\u1007\u1005\u0001\u0000\u0000\u0000\u1007\u1006\u0001\u0000\u0000"+ - "\u0000\u1008\u100c\u0001\u0000\u0000\u0000\u1009\u100a\u0005\u01d8\u0000"+ - "\u0000\u100a\u100c\u0005\u01e5\u0000\u0000\u100b\u1000\u0001\u0000\u0000"+ - "\u0000\u100b\u1009\u0001\u0000\u0000\u0000\u100c\u0165\u0001\u0000\u0000"+ - "\u0000\u100d\u100e\u0003\u0214\u010a\u0000\u100e\u0167\u0001\u0000\u0000"+ - "\u0000\u100f\u1010\u0005\u0122\u0000\u0000\u1010\u1018\u0005\u0134\u0000"+ - "\u0000\u1011\u1019\u0005\u0203\u0000\u0000\u1012\u1013\u0005\u01d5\u0000"+ - "\u0000\u1013\u1019\u0005\u01be\u0000\u0000\u1014\u1015\u0005\u01be\u0000"+ - "\u0000\u1015\u1019\u0005d\u0000\u0000\u1016\u1017\u0005\u01be\u0000\u0000"+ - "\u1017\u1019\u0005\u0260\u0000\u0000\u1018\u1011\u0001\u0000\u0000\u0000"+ - "\u1018\u1012\u0001\u0000\u0000\u0000\u1018\u1014\u0001\u0000\u0000\u0000"+ - "\u1018\u1016\u0001\u0000\u0000\u0000\u1019\u1023\u0001\u0000\u0000\u0000"+ - "\u101a\u101b\u0005\u01be\u0000\u0000\u101b\u1023\u0005\u028c\u0000\u0000"+ - "\u101c\u101d\u0005\u01be\u0000\u0000\u101d\u1023\u0005\u0181\u0000\u0000"+ - "\u101e\u1020\u0005\u016d\u0000\u0000\u101f\u101e\u0001\u0000\u0000\u0000"+ - "\u101f\u1020\u0001\u0000\u0000\u0000\u1020\u1021\u0001\u0000\u0000\u0000"+ - "\u1021\u1023\u0005\u009e\u0000\u0000\u1022\u100f\u0001\u0000\u0000\u0000"+ - "\u1022\u101a\u0001\u0000\u0000\u0000\u1022\u101c\u0001\u0000\u0000\u0000"+ - "\u1022\u101f\u0001\u0000\u0000\u0000\u1023\u0169\u0001\u0000\u0000\u0000"+ - "\u1024\u1029\u0003\u0168\u00b4\u0000\u1025\u1026\u0005\u02fa\u0000\u0000"+ - "\u1026\u1028\u0003\u0168\u00b4\u0000\u1027\u1025\u0001\u0000\u0000\u0000"+ - "\u1028\u102b\u0001\u0000\u0000\u0000\u1029\u1027\u0001\u0000\u0000\u0000"+ - "\u1029\u102a\u0001\u0000\u0000\u0000\u102a\u016b\u0001\u0000\u0000\u0000"+ - "\u102b\u1029\u0001\u0000\u0000\u0000\u102c\u102d\u0005\u0207\u0000\u0000"+ - "\u102d\u102e\u0005\u024c\u0000\u0000\u102e\u103a\u0003\u016a\u00b5\u0000"+ - "\u102f\u1030\u0005\u0207\u0000\u0000\u1030\u1031\u0005\u024c\u0000\u0000"+ - "\u1031\u1032\u0005\u0211\u0000\u0000\u1032\u103a\u0005\u030a\u0000\u0000"+ - "\u1033\u1034\u0005\u0207\u0000\u0000\u1034\u1035\u0005\u0205\u0000\u0000"+ - "\u1035\u1036\u0005L\u0000\u0000\u1036\u1037\u0005\u001b\u0000\u0000\u1037"+ - "\u1038\u0005\u024c\u0000\u0000\u1038\u103a\u0003\u016a\u00b5\u0000\u1039"+ - "\u102c\u0001\u0000\u0000\u0000\u1039\u102f\u0001\u0000\u0000\u0000\u1039"+ - "\u1033\u0001\u0000\u0000\u0000\u103a\u016d\u0001\u0000\u0000\u0000\u103b"+ - "\u1040\u0005\u020b\u0000\u0000\u103c\u1041\u0003\u0210\u0108\u0000\u103d"+ - "\u103e\u0005\u0242\u0000\u0000\u103e\u1041\u0005\u0290\u0000\u0000\u103f"+ - "\u1041\u0005\u0010\u0000\u0000\u1040\u103c\u0001\u0000\u0000\u0000\u1040"+ - "\u103d\u0001\u0000\u0000\u0000\u1040\u103f\u0001\u0000\u0000\u0000\u1041"+ - "\u016f\u0001\u0000\u0000\u0000\u1042\u1044\u0005\u025b\u0000\u0000\u1043"+ - "\u1045\u0005\u0237\u0000\u0000\u1044\u1043\u0001\u0000\u0000\u0000\u1044"+ - "\u1045\u0001\u0000\u0000\u0000\u1045\u1047\u0001\u0000\u0000\u0000\u1046"+ - "\u1048\u0005\u0181\u0000\u0000\u1047\u1046\u0001\u0000\u0000\u0000\u1047"+ - "\u1048\u0001\u0000\u0000\u0000\u1048\u1049\u0001\u0000\u0000\u0000\u1049"+ - "\u104b\u0003\u01e2\u00f1\u0000\u104a\u104c\u0005\u02ff\u0000\u0000\u104b"+ - "\u104a\u0001\u0000\u0000\u0000\u104b\u104c\u0001\u0000\u0000\u0000\u104c"+ - "\u1052\u0001\u0000\u0000\u0000\u104d\u104f\u0005\u02fa\u0000\u0000\u104e"+ - "\u1050\u0005\u0181\u0000\u0000\u104f\u104e\u0001\u0000\u0000\u0000\u104f"+ - "\u1050\u0001\u0000\u0000\u0000\u1050\u1051\u0001\u0000\u0000\u0000\u1051"+ - "\u1053\u0003\u01dc\u00ee\u0000\u1052\u104d\u0001\u0000\u0000\u0000\u1052"+ - "\u1053\u0001\u0000\u0000\u0000\u1053\u1056\u0001\u0000\u0000\u0000\u1054"+ - "\u1055\u0007\u0017\u0000\u0000\u1055\u1057\u0005\u0102\u0000\u0000\u1056"+ - "\u1054\u0001\u0000\u0000\u0000\u1056\u1057\u0001\u0000\u0000\u0000\u1057"+ - "\u1059\u0001\u0000\u0000\u0000\u1058\u105a\u0007\u0001\u0000\u0000\u1059"+ - "\u1058\u0001\u0000\u0000\u0000\u1059\u105a\u0001\u0000\u0000\u0000\u105a"+ - "\u0171\u0001\u0000\u0000\u0000\u105b\u105e\u0005\u0266\u0000\u0000\u105c"+ - "\u105f\u0003\u0210\u0108\u0000\u105d\u105f\u0005\u02ff\u0000\u0000\u105e"+ - "\u105c\u0001\u0000\u0000\u0000\u105e\u105d\u0001\u0000\u0000\u0000\u105f"+ - "\u0173\u0001\u0000\u0000\u0000\u1060\u1062\u0003\u015c\u00ae\u0000\u1061"+ - "\u1060\u0001\u0000\u0000\u0000\u1061\u1062\u0001\u0000\u0000\u0000\u1062"+ - "\u1063\u0001\u0000\u0000\u0000\u1063\u1065\u0005\u026b\u0000\u0000\u1064"+ - "\u1066\u0005\u0181\u0000\u0000\u1065\u1064\u0001\u0000\u0000\u0000\u1065"+ - "\u1066\u0001\u0000\u0000\u0000\u1066\u1067\u0001\u0000\u0000\u0000\u1067"+ - "\u1069\u0003\u01e2\u00f1\u0000\u1068\u106a\u0005\u02ff\u0000\u0000\u1069"+ - "\u1068\u0001\u0000\u0000\u0000\u1069\u106a\u0001\u0000\u0000\u0000\u106a"+ - "\u106f\u0001\u0000\u0000\u0000\u106b\u106d\u0005\u001b\u0000\u0000\u106c"+ - "\u106b\u0001\u0000\u0000\u0000\u106c\u106d\u0001\u0000\u0000\u0000\u106d"+ - "\u106e\u0001\u0000\u0000\u0000\u106e\u1070\u0003\u0210\u0108\u0000\u106f"+ - "\u106c\u0001\u0000\u0000\u0000\u106f\u1070\u0001\u0000\u0000\u0000\u1070"+ - "\u1071\u0001\u0000\u0000\u0000\u1071\u1072\u0005\u0207\u0000\u0000\u1072"+ - "\u1074\u0003\u01b2\u00d9\u0000\u1073\u1075\u0003\u0180\u00c0\u0000\u1074"+ - "\u1073\u0001\u0000\u0000\u0000\u1074\u1075\u0001\u0000\u0000\u0000\u1075"+ - "\u107b\u0001\u0000\u0000\u0000\u1076\u107c\u0003\u0182\u00c1\u0000\u1077"+ - "\u1078\u0005\u0285\u0000\u0000\u1078\u1079\u0005\u0085\u0000\u0000\u1079"+ - "\u107a\u0005\u017b\u0000\u0000\u107a\u107c\u0003\u0210\u0108\u0000\u107b"+ - "\u1076\u0001\u0000\u0000\u0000\u107b\u1077\u0001\u0000\u0000\u0000\u107b"+ - "\u107c\u0001\u0000\u0000\u0000\u107c\u107e\u0001\u0000\u0000\u0000\u107d"+ - "\u107f\u0003\u01b6\u00db\u0000\u107e\u107d\u0001\u0000\u0000\u0000\u107e"+ - "\u107f\u0001\u0000\u0000\u0000\u107f\u0175\u0001\u0000\u0000\u0000\u1080"+ - "\u1081\u0007\u0018\u0000\u0000\u1081\u0177\u0001\u0000\u0000\u0000\u1082"+ - "\u1087\u0003\u0176\u00bb\u0000\u1083\u1084\u0005\u02fa\u0000\u0000\u1084"+ - "\u1086\u0003\u0176\u00bb\u0000\u1085\u1083\u0001\u0000\u0000\u0000\u1086"+ - "\u1089\u0001\u0000\u0000\u0000\u1087\u1085\u0001\u0000\u0000\u0000\u1087"+ - "\u1088\u0001\u0000\u0000\u0000\u1088\u0179\u0001\u0000\u0000\u0000\u1089"+ - "\u1087\u0001\u0000\u0000\u0000\u108a\u108f\u0005\u0274\u0000\u0000\u108b"+ - "\u108c\u0005\u0300\u0000\u0000\u108c\u108d\u0003\u0178\u00bc\u0000\u108d"+ - "\u108e\u0005\u0301\u0000\u0000\u108e\u1090\u0001\u0000\u0000\u0000\u108f"+ - "\u108b\u0001\u0000\u0000\u0000\u108f\u1090\u0001\u0000\u0000\u0000\u1090"+ - "\u1091\u0001\u0000\u0000\u0000\u1091\u1096\u0003\u01e2\u00f1\u0000\u1092"+ - "\u1093\u0005\u0300\u0000\u0000\u1093\u1094\u0003\u018c\u00c6\u0000\u1094"+ - "\u1095\u0005\u0301\u0000\u0000\u1095\u1097\u0001\u0000\u0000\u0000\u1096"+ - "\u1092\u0001\u0000\u0000\u0000\u1096\u1097\u0001\u0000\u0000\u0000\u1097"+ - "\u10ba\u0001\u0000\u0000\u0000\u1098\u109a\u0005\u0274\u0000\u0000\u1099"+ - "\u109b\u0005\u00ed\u0000\u0000\u109a\u1099\u0001\u0000\u0000\u0000\u109a"+ - "\u109b\u0001\u0000\u0000\u0000\u109b\u109d\u0001\u0000\u0000\u0000\u109c"+ - "\u109e\u0005\u00eb\u0000\u0000\u109d\u109c\u0001\u0000\u0000\u0000\u109d"+ - "\u109e\u0001\u0000\u0000\u0000\u109e\u10a0\u0001\u0000\u0000\u0000\u109f"+ - "\u10a1\u0005\u0280\u0000\u0000\u10a0\u109f\u0001\u0000\u0000\u0000\u10a0"+ - "\u10a1\u0001\u0000\u0000\u0000\u10a1\u10a3\u0001\u0000\u0000\u0000\u10a2"+ - "\u10a4\u0003\u01e2\u00f1\u0000\u10a3\u10a2\u0001\u0000\u0000\u0000\u10a3"+ - "\u10a4\u0001\u0000\u0000\u0000\u10a4\u10ba\u0001\u0000\u0000\u0000\u10a5"+ - "\u10a7\u0005\u0274\u0000\u0000\u10a6\u10a8\u0005\u00ed\u0000\u0000\u10a7"+ - "\u10a6\u0001\u0000\u0000\u0000\u10a7\u10a8\u0001\u0000\u0000\u0000\u10a8"+ - "\u10aa\u0001\u0000\u0000\u0000\u10a9\u10ab\u0005\u00eb\u0000\u0000\u10aa"+ - "\u10a9\u0001\u0000\u0000\u0000\u10aa\u10ab\u0001\u0000\u0000\u0000\u10ab"+ - "\u10ad\u0001\u0000\u0000\u0000\u10ac\u10ae\u0005\u0280\u0000\u0000\u10ad"+ - "\u10ac\u0001\u0000\u0000\u0000\u10ad\u10ae\u0001\u0000\u0000\u0000\u10ae"+ - "\u10af\u0001\u0000\u0000\u0000\u10af\u10b7\u0005\u0016\u0000\u0000\u10b0"+ - "\u10b5\u0003\u01e2\u00f1\u0000\u10b1\u10b2\u0005\u0300\u0000\u0000\u10b2"+ - "\u10b3\u0003\u018c\u00c6\u0000\u10b3\u10b4\u0005\u0301\u0000\u0000\u10b4"+ - "\u10b6\u0001\u0000\u0000\u0000\u10b5\u10b1\u0001\u0000\u0000\u0000\u10b5"+ - "\u10b6\u0001\u0000\u0000\u0000\u10b6\u10b8\u0001\u0000\u0000\u0000\u10b7"+ - "\u10b0\u0001\u0000\u0000\u0000\u10b7\u10b8\u0001\u0000\u0000\u0000\u10b8"+ - "\u10ba\u0001\u0000\u0000\u0000\u10b9\u108a\u0001\u0000\u0000\u0000\u10b9"+ - "\u1098\u0001\u0000\u0000\u0000\u10b9\u10a5\u0001\u0000\u0000\u0000\u10ba"+ - "\u017b\u0001\u0000\u0000\u0000\u10bb\u10bd\u0003\u015c\u00ae\u0000\u10bc"+ - "\u10bb\u0001\u0000\u0000\u0000\u10bc\u10bd\u0001\u0000\u0000\u0000\u10bd"+ - "\u10cd\u0001\u0000\u0000\u0000\u10be\u10bf\u0005\u0279\u0000\u0000\u10bf"+ - "\u10ce\u0003\u01c6\u00e3\u0000\u10c0\u10c2\u0005\u0300\u0000\u0000\u10c1"+ - "\u10c0\u0001\u0000\u0000\u0000\u10c2\u10c3\u0001\u0000\u0000\u0000\u10c3"+ - "\u10c1\u0001\u0000\u0000\u0000\u10c3\u10c4\u0001\u0000\u0000\u0000\u10c4"+ - "\u10c5\u0001\u0000\u0000\u0000\u10c5\u10c7\u0003\u017c\u00be\u0000\u10c6"+ - "\u10c8\u0005\u0301\u0000\u0000\u10c7\u10c6\u0001\u0000\u0000\u0000\u10c8"+ - "\u10c9\u0001\u0000\u0000\u0000\u10c9\u10c7\u0001\u0000\u0000\u0000\u10c9"+ - "\u10ca\u0001\u0000\u0000\u0000\u10ca\u10cb\u0001\u0000\u0000\u0000\u10cb"+ - "\u10cc\u0003\u01a4\u00d2\u0000\u10cc\u10ce\u0001\u0000\u0000\u0000\u10cd"+ - "\u10be\u0001\u0000\u0000\u0000\u10cd\u10c1\u0001\u0000\u0000\u0000\u10ce"+ - "\u10d0\u0001\u0000\u0000\u0000\u10cf\u10d1\u0003\u01a6\u00d3\u0000\u10d0"+ - "\u10cf\u0001\u0000\u0000\u0000\u10d0\u10d1\u0001\u0000\u0000\u0000\u10d1"+ - "\u10d3\u0001\u0000\u0000\u0000\u10d2\u10d4\u0003\u01a4\u00d2\u0000\u10d3"+ - "\u10d2\u0001\u0000\u0000\u0000\u10d3\u10d4\u0001\u0000\u0000\u0000\u10d4"+ - "\u10d6\u0001\u0000\u0000\u0000\u10d5\u10d7\u0003\u01aa\u00d5\u0000\u10d6"+ - "\u10d5\u0001\u0000\u0000\u0000\u10d6\u10d7\u0001\u0000\u0000\u0000\u10d7"+ - "\u10d9\u0001\u0000\u0000\u0000\u10d8\u10da\u0003\u01ac\u00d6\u0000\u10d9"+ - "\u10d8\u0001\u0000\u0000\u0000\u10d9\u10da\u0001\u0000\u0000\u0000\u10da"+ - "\u10dc\u0001\u0000\u0000\u0000\u10db\u10dd\u0003\u01ae\u00d7\u0000\u10dc"+ - "\u10db\u0001\u0000\u0000\u0000\u10dc\u10dd\u0001\u0000\u0000\u0000\u10dd"+ - "\u017d\u0001\u0000\u0000\u0000\u10de\u10e7\u0005\u0010\u0000\u0000\u10df"+ - "\u10e2\u0005\u00b8\u0000\u0000\u10e0\u10e1\u0005\u0180\u0000\u0000\u10e1"+ - "\u10e3\u0003\u01c4\u00e2\u0000\u10e2\u10e0\u0001\u0000\u0000\u0000\u10e2"+ - "\u10e3\u0001\u0000\u0000\u0000\u10e3\u10e7\u0001\u0000\u0000\u0000\u10e4"+ - "\u10e5\u0005\u0249\u0000\u0000\u10e5\u10e7\u0005\u0307\u0000\u0000\u10e6"+ - "\u10de\u0001\u0000\u0000\u0000\u10e6\u10df\u0001\u0000\u0000\u0000\u10e6"+ - "\u10e4\u0001\u0000\u0000\u0000\u10e6\u10e7\u0001\u0000\u0000\u0000\u10e7"+ - "\u10e8\u0001\u0000\u0000\u0000\u10e8\u10e9\u0003\u018c\u00c6\u0000\u10e9"+ - "\u017f\u0001\u0000\u0000\u0000\u10ea\u10eb\u0005\u00ec\u0000\u0000\u10eb"+ - "\u10f0\u0003\u01f0\u00f8\u0000\u10ec\u10ed\u0005\u02fa\u0000\u0000\u10ed"+ - "\u10ef\u0003\u01f0\u00f8\u0000\u10ee\u10ec\u0001\u0000\u0000\u0000\u10ef"+ - "\u10f2\u0001\u0000\u0000\u0000\u10f0\u10ee\u0001\u0000\u0000\u0000\u10f0"+ - "\u10f1\u0001\u0000\u0000\u0000\u10f1\u0181\u0001\u0000\u0000\u0000\u10f2"+ - "\u10f0\u0001\u0000\u0000\u0000\u10f3\u10f4\u0005\u0285\u0000\u0000\u10f4"+ - "\u10f5\u0003\u01f8\u00fc\u0000\u10f5\u0183\u0001\u0000\u0000\u0000\u10f6"+ - "\u10f7\u0005\u00fa\u0000\u0000\u10f7\u10f8\u00056\u0000\u0000\u10f8\u10fd"+ - "\u0003\u0186\u00c3\u0000\u10f9\u10fa\u0005\u02fa\u0000\u0000\u10fa\u10fc"+ - "\u0003\u0186\u00c3\u0000\u10fb\u10f9\u0001\u0000\u0000\u0000\u10fc\u10ff"+ - "\u0001\u0000\u0000\u0000\u10fd\u10fb\u0001\u0000\u0000\u0000\u10fd\u10fe"+ - "\u0001\u0000\u0000\u0000\u10fe\u0185\u0001\u0000\u0000\u0000\u10ff\u10fd"+ - "\u0001\u0000\u0000\u0000\u1100\u1101\u0005\u0300\u0000\u0000\u1101\u111a"+ - "\u0005\u0301\u0000\u0000\u1102\u111a\u0003\u01b8\u00dc\u0000\u1103\u111a"+ - "\u0003\u01c4\u00e2\u0000\u1104\u1105\u0007\u0019\u0000\u0000\u1105\u1108"+ - "\u0005\u0300\u0000\u0000\u1106\u1109\u0003\u01b8\u00dc\u0000\u1107\u1109"+ - "\u0003\u01c4\u00e2\u0000\u1108\u1106\u0001\u0000\u0000\u0000\u1108\u1107"+ - "\u0001\u0000\u0000\u0000\u1109\u1111\u0001\u0000\u0000\u0000\u110a\u110d"+ - "\u0005\u02fa\u0000\u0000\u110b\u110e\u0003\u01b8\u00dc\u0000\u110c\u110e"+ - "\u0003\u01c4\u00e2\u0000\u110d\u110b\u0001\u0000\u0000\u0000\u110d\u110c"+ - "\u0001\u0000\u0000\u0000\u110e\u1110\u0001\u0000\u0000\u0000\u110f\u110a"+ - "\u0001\u0000\u0000\u0000\u1110\u1113\u0001\u0000\u0000\u0000\u1111\u110f"+ - "\u0001\u0000\u0000\u0000\u1111\u1112\u0001\u0000\u0000\u0000\u1112\u1114"+ - "\u0001\u0000\u0000\u0000\u1113\u1111\u0001\u0000\u0000\u0000\u1114\u1115"+ - "\u0005\u0301\u0000\u0000\u1115\u111a\u0001\u0000\u0000\u0000\u1116\u1117"+ - "\u0005\u00fb\u0000\u0000\u1117\u1118\u0005\u0209\u0000\u0000\u1118\u111a"+ - "\u0003\u0188\u00c4\u0000\u1119\u1100\u0001\u0000\u0000\u0000\u1119\u1102"+ - "\u0001\u0000\u0000\u0000\u1119\u1103\u0001\u0000\u0000\u0000\u1119\u1104"+ - "\u0001\u0000\u0000\u0000\u1119\u1116\u0001\u0000\u0000\u0000\u111a\u0187"+ - "\u0001\u0000\u0000\u0000\u111b\u111c\u0005\u0300\u0000\u0000\u111c\u1121"+ - "\u0003\u0186\u00c3\u0000\u111d\u111e\u0005\u02fa\u0000\u0000\u111e\u1120"+ - "\u0003\u0186\u00c3\u0000\u111f\u111d\u0001\u0000\u0000\u0000\u1120\u1123"+ - "\u0001\u0000\u0000\u0000\u1121\u111f\u0001\u0000\u0000\u0000\u1121\u1122"+ - "\u0001\u0000\u0000\u0000\u1122\u1124\u0001\u0000\u0000\u0000\u1123\u1121"+ - "\u0001\u0000\u0000\u0000\u1124\u1125\u0005\u0301\u0000\u0000\u1125\u0189"+ - "\u0001\u0000\u0000\u0000\u1126\u1127\u0005\u00fd\u0000\u0000\u1127\u112c"+ - "\u0003\u01f8\u00fc\u0000\u1128\u1129\u0005\u02fa\u0000\u0000\u1129\u112b"+ - "\u0003\u01f8\u00fc\u0000\u112a\u1128\u0001\u0000\u0000\u0000\u112b\u112e"+ - "\u0001\u0000\u0000\u0000\u112c\u112a\u0001\u0000\u0000\u0000\u112c\u112d"+ - "\u0001\u0000\u0000\u0000\u112d\u018b\u0001\u0000\u0000\u0000\u112e\u112c"+ - "\u0001\u0000\u0000\u0000\u112f\u1134\u0003\u01b8\u00dc\u0000\u1130\u1132"+ - "\u0005\u001b\u0000\u0000\u1131\u1130\u0001\u0000\u0000\u0000\u1131\u1132"+ - "\u0001\u0000\u0000\u0000\u1132\u1133\u0001\u0000\u0000\u0000\u1133\u1135"+ - "\u0003\u01d8\u00ec\u0000\u1134\u1131\u0001\u0000\u0000\u0000\u1134\u1135"+ - "\u0001\u0000\u0000\u0000\u1135\u1138\u0001\u0000\u0000\u0000\u1136\u1138"+ - "\u0005\u02ff\u0000\u0000\u1137\u112f\u0001\u0000\u0000\u0000\u1137\u1136"+ - "\u0001\u0000\u0000\u0000\u1138\u1146\u0001\u0000\u0000\u0000\u1139\u1142"+ - "\u0005\u02fa\u0000\u0000\u113a\u113f\u0003\u01b8\u00dc\u0000\u113b\u113d"+ - "\u0005\u001b\u0000\u0000\u113c\u113b\u0001\u0000\u0000\u0000\u113c\u113d"+ - "\u0001\u0000\u0000\u0000\u113d\u113e\u0001\u0000\u0000\u0000\u113e\u1140"+ - "\u0003\u01d8\u00ec\u0000\u113f\u113c\u0001\u0000\u0000\u0000\u113f\u1140"+ - "\u0001\u0000\u0000\u0000\u1140\u1143\u0001\u0000\u0000\u0000\u1141\u1143"+ - "\u0005\u02ff\u0000\u0000\u1142\u113a\u0001\u0000\u0000\u0000\u1142\u1141"+ - "\u0001\u0000\u0000\u0000\u1143\u1145\u0001\u0000\u0000\u0000\u1144\u1139"+ - "\u0001\u0000\u0000\u0000\u1145\u1148\u0001\u0000\u0000\u0000\u1146\u1144"+ - "\u0001\u0000\u0000\u0000\u1146\u1147\u0001\u0000\u0000\u0000\u1147\u018d"+ - "\u0001\u0000\u0000\u0000\u1148\u1146\u0001\u0000\u0000\u0000\u1149\u114b"+ - "\u0007\u001a\u0000\u0000\u114a\u114c\u0003\u020a\u0105\u0000\u114b\u114a"+ - "\u0001\u0000\u0000\u0000\u114b\u114c\u0001\u0000\u0000\u0000\u114c\u1150"+ - "\u0001\u0000\u0000\u0000\u114d\u114e\u0005\u00e6\u0000\u0000\u114e\u1150"+ - "\u0007\u001b\u0000\u0000\u114f\u1149\u0001\u0000\u0000\u0000\u114f\u114d"+ - "\u0001\u0000\u0000\u0000\u1150\u018f\u0001\u0000\u0000\u0000\u1151\u1152"+ - "\u0005\u025f\u0000\u0000\u1152\u115e\u0005\u01ad\u0000\u0000\u1153\u1154"+ - "\u0003\u01bc\u00de\u0000\u1154\u1155\u0005\u01ad\u0000\u0000\u1155\u115e"+ - "\u0001\u0000\u0000\u0000\u1156\u1157\u0005\u0085\u0000\u0000\u1157\u115e"+ - "\u0005\u01ec\u0000\u0000\u1158\u1159\u0003\u01bc\u00de\u0000\u1159\u115a"+ - "\u0005\u00e2\u0000\u0000\u115a\u115e\u0001\u0000\u0000\u0000\u115b\u115c"+ - "\u0005\u025f\u0000\u0000\u115c\u115e\u0005\u00e2\u0000\u0000\u115d\u1151"+ - "\u0001\u0000\u0000\u0000\u115d\u1153\u0001\u0000\u0000\u0000\u115d\u1156"+ - "\u0001\u0000\u0000\u0000\u115d\u1158\u0001\u0000\u0000\u0000\u115d\u115b"+ - "\u0001\u0000\u0000\u0000\u115e\u0191\u0001\u0000\u0000\u0000\u115f\u1160"+ - "\u0003\u0190\u00c8\u0000\u1160\u0193\u0001\u0000\u0000\u0000\u1161\u1162"+ - "\u0003\u0190\u00c8\u0000\u1162\u0195\u0001\u0000\u0000\u0000\u1163\u1164"+ - "\u0007\u001c\u0000\u0000\u1164\u116c\u0003\u0192\u00c9\u0000\u1165\u1166"+ - "\u0007\u001c\u0000\u0000\u1166\u1167\u0005+\u0000\u0000\u1167\u1168\u0003"+ - "\u0192\u00c9\u0000\u1168\u1169\u0005\u0017\u0000\u0000\u1169\u116a\u0003"+ - "\u0194\u00ca\u0000\u116a\u116c\u0001\u0000\u0000\u0000\u116b\u1163\u0001"+ - "\u0000\u0000\u0000\u116b\u1165\u0001\u0000\u0000\u0000\u116c\u0197\u0001"+ - "\u0000\u0000\u0000\u116d\u1172\u0003\u019a\u00cd\u0000\u116e\u116f\u0005"+ - "\u02fa\u0000\u0000\u116f\u1171\u0003\u019a\u00cd\u0000\u1170\u116e\u0001"+ - "\u0000\u0000\u0000\u1171\u1174\u0001\u0000\u0000\u0000\u1172\u1170\u0001"+ - "\u0000\u0000\u0000\u1172\u1173\u0001"; + "\u0005\u0148\u0000\u0000\u084d\u084e\u0005\u015a\u0000\u0000\u084e\u084f"+ + "\u0003\u053c\u029e\u0000\u084f\u0850\u0003\u03aa\u01d5\u0000\u0850\u0889"+ + "\u0001\u0000\u0000\u0000\u0851\u0852\u0005\u008c\u0000\u0000\u0852\u0855"+ + "\u0005\u0143\u0000\u0000\u0853\u0854\u0005\u00de\u0000\u0000\u0854\u0856"+ + "\u0005\u0187\u0000\u0000\u0855\u0853\u0001\u0000\u0000\u0000\u0855\u0856"+ + "\u0001\u0000\u0000\u0000\u0856\u0857\u0001\u0000\u0000\u0000\u0857\u0858"+ + "\u0003\u0538\u029c\u0000\u0858\u0859\u0003b1\u0000\u0859\u0889\u0001\u0000"+ + "\u0000\u0000\u085a\u085b\u0005\u008c\u0000\u0000\u085b\u085e\u0005\u0173"+ + "\u0000\u0000\u085c\u085d\u0005\u00de\u0000\u0000\u085d\u085f\u0005\u0187"+ + "\u0000\u0000\u085e\u085c\u0001\u0000\u0000\u0000\u085e\u085f\u0001\u0000"+ + "\u0000\u0000\u085f\u0860\u0001\u0000\u0000\u0000\u0860\u0861\u0003\u0538"+ + "\u029c\u0000\u0861\u0862\u0003b1\u0000\u0862\u0889\u0001\u0000\u0000\u0000"+ + "\u0863\u0864\u0005\u008c\u0000\u0000\u0864\u0865\u0005\u00fd\u0000\u0000"+ + "\u0865\u0868\u0005\u0173\u0000\u0000\u0866\u0867\u0005\u00de\u0000\u0000"+ + "\u0867\u0869\u0005\u0187\u0000\u0000\u0868\u0866\u0001\u0000\u0000\u0000"+ + "\u0868\u0869\u0001\u0000\u0000\u0000\u0869\u086a\u0001\u0000\u0000\u0000"+ + "\u086a\u086b\u0003\u0538\u029c\u0000\u086b\u086c\u0003b1\u0000\u086c\u0889"+ + "\u0001\u0000\u0000\u0000\u086d\u086e\u0005\u008c\u0000\u0000\u086e\u086f"+ + "\u0005\u00fd\u0000\u0000\u086f\u0870\u0005\u0173\u0000\u0000\u0870\u0871"+ + "\u0005 \u0000\u0000\u0871\u0872\u0005F\u0000\u0000\u0872\u0873\u0005\u015a"+ + "\u0000\u0000\u0873\u0877\u0003\u053c\u029e\u0000\u0874\u0875\u0005\u0114"+ + "\u0000\u0000\u0875\u0876\u0005\u0095\u0000\u0000\u0876\u0878\u0003\u055a"+ + "\u02ad\u0000\u0877\u0874\u0001\u0000\u0000\u0000\u0877\u0878\u0001\u0000"+ + "\u0000\u0000\u0878\u0879\u0001\u0000\u0000\u0000\u0879\u087a\u0005\u0148"+ + "\u0000\u0000\u087a\u087b\u0005\u015a\u0000\u0000\u087b\u087c\u0003\u053c"+ + "\u029e\u0000\u087c\u087d\u0003\u03aa\u01d5\u0000\u087d\u0889\u0001\u0000"+ + "\u0000\u0000\u087e\u087f\u0005\u008c\u0000\u0000\u087f\u0880\u0005A\u0000"+ + "\u0000\u0880\u0883\u0005^\u0000\u0000\u0881\u0882\u0005\u00de\u0000\u0000"+ + "\u0882\u0884\u0005\u0187\u0000\u0000\u0883\u0881\u0001\u0000\u0000\u0000"+ + "\u0883\u0884\u0001\u0000\u0000\u0000\u0884\u0885\u0001\u0000\u0000\u0000"+ + "\u0885\u0886\u0003\u0434\u021a\u0000\u0886\u0887\u0003b1\u0000\u0887\u0889"+ + "\u0001\u0000\u0000\u0000\u0888\u081b\u0001\u0000\u0000\u0000\u0888\u0826"+ + "\u0001\u0000\u0000\u0000\u0888\u0836\u0001\u0000\u0000\u0000\u0888\u0841"+ + "\u0001\u0000\u0000\u0000\u0888\u0851\u0001\u0000\u0000\u0000\u0888\u085a"+ + "\u0001\u0000\u0000\u0000\u0888\u0863\u0001\u0000\u0000\u0000\u0888\u086d"+ + "\u0001\u0000\u0000\u0000\u0888\u087e\u0001\u0000\u0000\u0000\u0889a\u0001"+ + "\u0000\u0000\u0000\u088a\u088f\u0003h4\u0000\u088b\u088c\u0005\u0007\u0000"+ + "\u0000\u088c\u088e\u0003h4\u0000\u088d\u088b\u0001\u0000\u0000\u0000\u088e"+ + "\u0891\u0001\u0000\u0000\u0000\u088f\u088d\u0001\u0000\u0000\u0000\u088f"+ + "\u0890\u0001\u0000\u0000\u0000\u0890c\u0001\u0000\u0000\u0000\u0891\u088f"+ + "\u0001\u0000\u0000\u0000\u0892\u0893\u0005\u01b5\u0000\u0000\u0893\u0894"+ + "\u0005\u0118\u0000\u0000\u0894\u0895\u0003\u0538\u029c\u0000\u0895\u0896"+ + "\u0003\u0080@\u0000\u0896\u089b\u0001\u0000\u0000\u0000\u0897\u0898\u0005"+ + "\u01b6\u0000\u0000\u0898\u0899\u0005\u0118\u0000\u0000\u0899\u089b\u0003"+ + "\u0538\u029c\u0000\u089a\u0892\u0001\u0000\u0000\u0000\u089a\u0897\u0001"+ + "\u0000\u0000\u0000\u089be\u0001\u0000\u0000\u0000\u089c\u089d\u0005\u01b5"+ + "\u0000\u0000\u089d\u089e\u0005\u0118\u0000\u0000\u089e\u089f\u0003\u0538"+ + "\u029c\u0000\u089fg\u0001\u0000\u0000\u0000\u08a0\u08a1\u0005\u0087\u0000"+ + "\u0000\u08a1\u099d\u0003\u00bc^\u0000\u08a2\u08a3\u0005\u0087\u0000\u0000"+ + "\u08a3\u08a4\u0005\u00de\u0000\u0000\u08a4\u08a5\u0005O\u0000\u0000\u08a5"+ + "\u08a6\u0005\u0187\u0000\u0000\u08a6\u099d\u0003\u00bc^\u0000\u08a7\u08a8"+ + "\u0005\u0087\u0000\u0000\u08a8\u08a9\u0005.\u0000\u0000\u08a9\u099d\u0003"+ + "\u00bc^\u0000\u08aa\u08ab\u0005\u0087\u0000\u0000\u08ab\u08ac\u0005.\u0000"+ + "\u0000\u08ac\u08ad\u0005\u00de\u0000\u0000\u08ad\u08ae\u0005O\u0000\u0000"+ + "\u08ae\u08af\u0005\u0187\u0000\u0000\u08af\u099d\u0003\u00bc^\u0000\u08b0"+ + "\u08b1\u0005\u008c\u0000\u0000\u08b1\u08b2\u0003\u02d4\u016a\u0000\u08b2"+ + "\u08b3\u0003\u055c\u02ae\u0000\u08b3\u08b4\u0003j5\u0000\u08b4\u099d\u0001"+ + "\u0000\u0000\u0000\u08b5\u08b6\u0005\u008c\u0000\u0000\u08b6\u08b7\u0003"+ + "\u02d4\u016a\u0000\u08b7\u08b8\u0003\u055c\u02ae\u0000\u08b8\u08b9\u0005"+ + "\u00c1\u0000\u0000\u08b9\u08ba\u0005O\u0000\u0000\u08ba\u08bb\u0005P\u0000"+ + "\u0000\u08bb\u099d\u0001\u0000\u0000\u0000\u08bc\u08bd\u0005\u008c\u0000"+ + "\u0000\u08bd\u08be\u0003\u02d4\u016a\u0000\u08be\u08bf\u0003\u055c\u02ae"+ + "\u0000\u08bf\u08c0\u0005\u0148\u0000\u0000\u08c0\u08c1\u0005O\u0000\u0000"+ + "\u08c1\u08c2\u0005P\u0000\u0000\u08c2\u099d\u0001\u0000\u0000\u0000\u08c3"+ + "\u08c4\u0005\u008c\u0000\u0000\u08c4\u08c5\u0003\u02d4\u016a\u0000\u08c5"+ + "\u08c6\u0003\u055c\u02ae\u0000\u08c6\u08c7\u0005\u00c1\u0000\u0000\u08c7"+ + "\u08c8\u0005\u01b7\u0000\u0000\u08c8\u099d\u0001\u0000\u0000\u0000\u08c9"+ + "\u08ca\u0005\u008c\u0000\u0000\u08ca\u08cb\u0003\u02d4\u016a\u0000\u08cb"+ + "\u08cc\u0003\u055c\u02ae\u0000\u08cc\u08cd\u0005\u00c1\u0000\u0000\u08cd"+ + "\u08ce\u0005\u01b7\u0000\u0000\u08ce\u08cf\u0005\u00de\u0000\u0000\u08cf"+ + "\u08d0\u0005\u0187\u0000\u0000\u08d0\u099d\u0001\u0000\u0000\u0000\u08d1"+ + "\u08d2\u0005\u008c\u0000\u0000\u08d2\u08d3\u0003\u02d4\u016a\u0000\u08d3"+ + "\u08d4\u0003\u055c\u02ae\u0000\u08d4\u08d5\u0005\u0148\u0000\u0000\u08d5"+ + "\u08d6\u0005\u0151\u0000\u0000\u08d6\u08d7\u0003\u0554\u02aa\u0000\u08d7"+ + "\u099d\u0001\u0000\u0000\u0000\u08d8\u08d9\u0005\u008c\u0000\u0000\u08d9"+ + "\u08da\u0003\u02d4\u016a\u0000\u08da\u08db\u0003\u054c\u02a6\u0000\u08db"+ + "\u08dc\u0005\u0148\u0000\u0000\u08dc\u08dd\u0005\u0151\u0000\u0000\u08dd"+ + "\u08de\u0003\u0554\u02aa\u0000\u08de\u099d\u0001\u0000\u0000\u0000\u08df"+ + "\u08e0\u0005\u008c\u0000\u0000\u08e0\u08e1\u0003\u02d4\u016a\u0000\u08e1"+ + "\u08e2\u0003\u055c\u02ae\u0000\u08e2\u08e3\u0005\u0148\u0000\u0000\u08e3"+ + "\u08e4\u0003t:\u0000\u08e4\u099d\u0001\u0000\u0000\u0000\u08e5\u08e6\u0005"+ + "\u008c\u0000\u0000\u08e6\u08e7\u0003\u02d4\u016a\u0000\u08e7\u08e8\u0003"+ + "\u055c\u02ae\u0000\u08e8\u08e9\u0005\u0134\u0000\u0000\u08e9\u08ea\u0003"+ + "t:\u0000\u08ea\u099d\u0001\u0000\u0000\u0000\u08eb\u08ec\u0005\u008c\u0000"+ + "\u0000\u08ec\u08ed\u0003\u02d4\u016a\u0000\u08ed\u08ee\u0003\u055c\u02ae"+ + "\u0000\u08ee\u08ef\u0005\u0148\u0000\u0000\u08ef\u08f0\u0005\u0154\u0000"+ + "\u0000\u08f0\u08f1\u0003\u055c\u02ae\u0000\u08f1\u099d\u0001\u0000\u0000"+ + "\u0000\u08f2\u08f3\u0005\u008c\u0000\u0000\u08f3\u08f4\u0003\u02d4\u016a"+ + "\u0000\u08f4\u08f5\u0003\u055c\u02ae\u0000\u08f5\u08f6\u0005\u0087\u0000"+ + "\u0000\u08f6\u08f7\u0005\u01b8\u0000\u0000\u08f7\u08f8\u0003\u00c6c\u0000"+ + "\u08f8\u08f9\u0005&\u0000\u0000\u08f9\u08fa\u0005\u00dd\u0000\u0000\u08fa"+ + "\u08fb\u0003\u011c\u008e\u0000\u08fb\u099d\u0001\u0000\u0000\u0000\u08fc"+ + "\u08fd\u0005\u008c\u0000\u0000\u08fd\u08fe\u0003\u02d4\u016a\u0000\u08fe"+ + "\u08ff\u0003\u055c\u02ae\u0000\u08ff\u0900\u0003|>\u0000\u0900\u099d\u0001"+ + "\u0000\u0000\u0000\u0901\u0902\u0005\u008c\u0000\u0000\u0902\u0903\u0003"+ + "\u02d4\u016a\u0000\u0903\u0904\u0003\u055c\u02ae\u0000\u0904\u0905\u0005"+ + "\u00c1\u0000\u0000\u0905\u0906\u0005\u00dd\u0000\u0000\u0906\u099d\u0001"+ + "\u0000\u0000\u0000\u0907\u0908\u0005\u008c\u0000\u0000\u0908\u0909\u0003"+ + "\u02d4\u016a\u0000\u0909\u090a\u0003\u055c\u02ae\u0000\u090a\u090b\u0005"+ + "\u00c1\u0000\u0000\u090b\u090c\u0005\u00dd\u0000\u0000\u090c\u090d\u0005"+ + "\u00de\u0000\u0000\u090d\u090e\u0005\u0187\u0000\u0000\u090e\u099d\u0001"+ + "\u0000\u0000\u0000\u090f\u0910\u0005\u00c1\u0000\u0000\u0910\u0911\u0003"+ + "\u02d4\u016a\u0000\u0911\u0912\u0005\u00de\u0000\u0000\u0912\u0913\u0005"+ + "\u0187\u0000\u0000\u0913\u0914\u0003\u055c\u02ae\u0000\u0914\u0915\u0003"+ + "l6\u0000\u0915\u099d\u0001\u0000\u0000\u0000\u0916\u0917\u0005\u00c1\u0000"+ + "\u0000\u0917\u0918\u0003\u02d4\u016a\u0000\u0918\u0919\u0003\u055c\u02ae"+ + "\u0000\u0919\u091a\u0003l6\u0000\u091a\u099d\u0001\u0000\u0000\u0000\u091b"+ + "\u091c\u0005\u008c\u0000\u0000\u091c\u091d\u0003\u02d4\u016a\u0000\u091d"+ + "\u091e\u0003\u055c\u02ae\u0000\u091e\u091f\u0003\u02d6\u016b\u0000\u091f"+ + "\u0920\u0005\u0163\u0000\u0000\u0920\u0921\u0003\u0460\u0230\u0000\u0921"+ + "\u0922\u0003n7\u0000\u0922\u0923\u0003p8\u0000\u0923\u099d\u0001\u0000"+ + "\u0000\u0000\u0924\u0925\u0005\u008c\u0000\u0000\u0925\u0926\u0003\u02d4"+ + "\u016a\u0000\u0926\u0927\u0003\u055c\u02ae\u0000\u0927\u0928\u0003\u0158"+ + "\u00ac\u0000\u0928\u099d\u0001\u0000\u0000\u0000\u0929\u092a\u0005\u0087"+ + "\u0000\u0000\u092a\u099d\u0003\u00d0h\u0000\u092b\u092c\u0005\u008c\u0000"+ + "\u0000\u092c\u092d\u0005/\u0000\u0000\u092d\u092e\u0003\u053c\u029e\u0000"+ + "\u092e\u092f\u0003\u01b8\u00dc\u0000\u092f\u099d\u0001\u0000\u0000\u0000"+ + "\u0930\u0931\u0005\u016f\u0000\u0000\u0931\u0932\u0005/\u0000\u0000\u0932"+ + "\u099d\u0003\u053c\u029e\u0000\u0933\u0934\u0005\u00c1\u0000\u0000\u0934"+ + "\u0935\u0005/\u0000\u0000\u0935\u0936\u0005\u00de\u0000\u0000\u0936\u0937"+ + "\u0005\u0187\u0000\u0000\u0937\u0938\u0003\u053c\u029e\u0000\u0938\u0939"+ + "\u0003l6\u0000\u0939\u099d\u0001\u0000\u0000\u0000\u093a\u093b\u0005\u00c1"+ + "\u0000\u0000\u093b\u093c\u0005/\u0000\u0000\u093c\u093d\u0003\u053c\u029e"+ + "\u0000\u093d\u093e\u0003l6\u0000\u093e\u099d\u0001\u0000\u0000\u0000\u093f"+ + "\u0940\u0005\u0148\u0000\u0000\u0940\u0941\u0005\u0176\u0000\u0000\u0941"+ + "\u099d\u0005\u0110\u0000\u0000\u0942\u0943\u0005\u00a0\u0000\u0000\u0943"+ + "\u0944\u0005R\u0000\u0000\u0944\u099d\u0003\u053c\u029e\u0000\u0945\u0946"+ + "\u0005\u0148\u0000\u0000\u0946\u0947\u0005\u0176\u0000\u0000\u0947\u099d"+ + "\u0005\u00a0\u0000\u0000\u0948\u0949\u0005\u0148\u0000\u0000\u0949\u099d"+ + "\u0005\u01b9\u0000\u0000\u094a\u094b\u0005\u0148\u0000\u0000\u094b\u099d"+ + "\u0005\u016a\u0000\u0000\u094c\u094d\u0005\u00c3\u0000\u0000\u094d\u094e"+ + "\u0005\u0160\u0000\u0000\u094e\u099d\u0003\u053c\u029e\u0000\u094f\u0950"+ + "\u0005\u00c3\u0000\u0000\u0950\u0951\u0005\u008d\u0000\u0000\u0951\u0952"+ + "\u0005\u0160\u0000\u0000\u0952\u099d\u0003\u053c\u029e\u0000\u0953\u0954"+ + "\u0005\u00c3\u0000\u0000\u0954\u0955\u0005\u0133\u0000\u0000\u0955\u0956"+ + "\u0005\u0160\u0000\u0000\u0956\u099d\u0003\u053c\u029e\u0000\u0957\u0958"+ + "\u0005\u00c3\u0000\u0000\u0958\u0959\u0005\u0160\u0000\u0000\u0959\u099d"+ + "\u0005 \u0000\u0000\u095a\u095b\u0005\u00c3\u0000\u0000\u095b\u095c\u0005"+ + "\u0160\u0000\u0000\u095c\u099d\u0005e\u0000\u0000\u095d\u095e\u0005\u00bc"+ + "\u0000\u0000\u095e\u095f\u0005\u0160\u0000\u0000\u095f\u099d\u0003\u053c"+ + "\u029e\u0000\u0960\u0961\u0005\u00bc\u0000\u0000\u0961\u0962\u0005\u0160"+ + "\u0000\u0000\u0962\u099d\u0005 \u0000\u0000\u0963\u0964\u0005\u00bc\u0000"+ + "\u0000\u0964\u0965\u0005\u0160\u0000\u0000\u0965\u099d\u0005e\u0000\u0000"+ + "\u0966\u0967\u0005\u00c3\u0000\u0000\u0967\u0968\u0005\u013c\u0000\u0000"+ + "\u0968\u099d\u0003\u053c\u029e\u0000\u0969\u096a\u0005\u00c3\u0000\u0000"+ + "\u096a\u096b\u0005\u008d\u0000\u0000\u096b\u096c\u0005\u013c\u0000\u0000"+ + "\u096c\u099d\u0003\u053c\u029e\u0000\u096d\u096e\u0005\u00c3\u0000\u0000"+ + "\u096e\u096f\u0005\u0133\u0000\u0000\u096f\u0970\u0005\u013c\u0000\u0000"+ + "\u0970\u099d\u0003\u053c\u029e\u0000\u0971\u0972\u0005\u00bc\u0000\u0000"+ + "\u0972\u0973\u0005\u013c\u0000\u0000\u0973\u099d\u0003\u053c\u029e\u0000"+ + "\u0974\u0975\u0005\u00e6\u0000\u0000\u0975\u099d\u0003\u0538\u029c\u0000"+ + "\u0976\u0977\u0005\u0108\u0000\u0000\u0977\u0978\u0005\u00e6\u0000\u0000"+ + "\u0978\u099d\u0003\u0538\u029c\u0000\u0979\u097a\u0005\u010e\u0000\u0000"+ + "\u097a\u099d\u0003\u020c\u0106\u0000\u097b\u097c\u0005O\u0000\u0000\u097c"+ + "\u099d\u0005\u010e\u0000\u0000\u097d\u097e\u0005\u0115\u0000\u0000\u097e"+ + "\u097f\u0005`\u0000\u0000\u097f\u099d\u0003\u0558\u02ac\u0000\u0980\u0981"+ + "\u0005\u0148\u0000\u0000\u0981\u0982\u0005\u015a\u0000\u0000\u0982\u099d"+ + "\u0003\u053c\u029e\u0000\u0983\u0984\u0005\u0148\u0000\u0000\u0984\u099d"+ + "\u0003t:\u0000\u0985\u0986\u0005\u0134\u0000\u0000\u0986\u099d\u0003t"+ + ":\u0000\u0987\u0988\u0005\u0133\u0000\u0000\u0988\u0989\u0005\u00dd\u0000"+ + "\u0000\u0989\u099d\u0003r9\u0000\u098a\u098b\u0005\u00c3\u0000\u0000\u098b"+ + "\u098c\u0005\u0199\u0000\u0000\u098c\u098d\u0005\u00f4\u0000\u0000\u098d"+ + "\u099d\u0005\u0142\u0000\u0000\u098e\u098f\u0005\u00bc\u0000\u0000\u098f"+ + "\u0990\u0005\u0199\u0000\u0000\u0990\u0991\u0005\u00f4\u0000\u0000\u0991"+ + "\u099d\u0005\u0142\u0000\u0000\u0992\u0993\u0005\u00d3\u0000\u0000\u0993"+ + "\u0994\u0005\u0199\u0000\u0000\u0994\u0995\u0005\u00f4\u0000\u0000\u0995"+ + "\u099d\u0005\u0142\u0000\u0000\u0996\u0997\u0005\u0108\u0000\u0000\u0997"+ + "\u0998\u0005\u00d3\u0000\u0000\u0998\u0999\u0005\u0199\u0000\u0000\u0999"+ + "\u099a\u0005\u00f4\u0000\u0000\u099a\u099d\u0005\u0142\u0000\u0000\u099b"+ + "\u099d\u0003\u0158\u00ac\u0000\u099c\u08a0\u0001\u0000\u0000\u0000\u099c"+ + "\u08a2\u0001\u0000\u0000\u0000\u099c\u08a7\u0001\u0000\u0000\u0000\u099c"+ + "\u08aa\u0001\u0000\u0000\u0000\u099c\u08b0\u0001\u0000\u0000\u0000\u099c"+ + "\u08b5\u0001\u0000\u0000\u0000\u099c\u08bc\u0001\u0000\u0000\u0000\u099c"+ + "\u08c3\u0001\u0000\u0000\u0000\u099c\u08c9\u0001\u0000\u0000\u0000\u099c"+ + "\u08d1\u0001\u0000\u0000\u0000\u099c\u08d8\u0001\u0000\u0000\u0000\u099c"+ + "\u08df\u0001\u0000\u0000\u0000\u099c\u08e5\u0001\u0000\u0000\u0000\u099c"+ + "\u08eb\u0001\u0000\u0000\u0000\u099c\u08f2\u0001\u0000\u0000\u0000\u099c"+ + "\u08fc\u0001\u0000\u0000\u0000\u099c\u0901\u0001\u0000\u0000\u0000\u099c"+ + "\u0907\u0001\u0000\u0000\u0000\u099c\u090f\u0001\u0000\u0000\u0000\u099c"+ + "\u0916\u0001\u0000\u0000\u0000\u099c\u091b\u0001\u0000\u0000\u0000\u099c"+ + "\u0924\u0001\u0000\u0000\u0000\u099c\u0929\u0001\u0000\u0000\u0000\u099c"+ + "\u092b\u0001\u0000\u0000\u0000\u099c\u0930\u0001\u0000\u0000\u0000\u099c"+ + "\u0933\u0001\u0000\u0000\u0000\u099c\u093a\u0001\u0000\u0000\u0000\u099c"+ + "\u093f\u0001\u0000\u0000\u0000\u099c\u0942\u0001\u0000\u0000\u0000\u099c"+ + "\u0945\u0001\u0000\u0000\u0000\u099c\u0948\u0001\u0000\u0000\u0000\u099c"+ + "\u094a\u0001\u0000\u0000\u0000\u099c\u094c\u0001\u0000\u0000\u0000\u099c"+ + "\u094f\u0001\u0000\u0000\u0000\u099c\u0953\u0001\u0000\u0000\u0000\u099c"+ + "\u0957\u0001\u0000\u0000\u0000\u099c\u095a\u0001\u0000\u0000\u0000\u099c"+ + "\u095d\u0001\u0000\u0000\u0000\u099c\u0960\u0001\u0000\u0000\u0000\u099c"+ + "\u0963\u0001\u0000\u0000\u0000\u099c\u0966\u0001\u0000\u0000\u0000\u099c"+ + "\u0969\u0001\u0000\u0000\u0000\u099c\u096d\u0001\u0000\u0000\u0000\u099c"+ + "\u0971\u0001\u0000\u0000\u0000\u099c\u0974\u0001\u0000\u0000\u0000\u099c"+ + "\u0976\u0001\u0000\u0000\u0000\u099c\u0979\u0001\u0000\u0000\u0000\u099c"+ + "\u097b\u0001\u0000\u0000\u0000\u099c\u097d\u0001\u0000\u0000\u0000\u099c"+ + "\u0980\u0001\u0000\u0000\u0000\u099c\u0983\u0001\u0000\u0000\u0000\u099c"+ + "\u0985\u0001\u0000\u0000\u0000\u099c\u0987\u0001\u0000\u0000\u0000\u099c"+ + "\u098a\u0001\u0000\u0000\u0000\u099c\u098e\u0001\u0000\u0000\u0000\u099c"+ + "\u0992\u0001\u0000\u0000\u0000\u099c\u0996\u0001\u0000\u0000\u0000\u099c"+ + "\u099b\u0001\u0000\u0000\u0000\u099di\u0001\u0000\u0000\u0000\u099e\u099f"+ + "\u0005\u0148\u0000\u0000\u099f\u09a0\u00057\u0000\u0000\u09a0\u09a4\u0003"+ + "\u048c\u0246\u0000\u09a1\u09a2\u0005\u00c1\u0000\u0000\u09a2\u09a4\u0005"+ + "7\u0000\u0000\u09a3\u099e\u0001\u0000\u0000\u0000\u09a3\u09a1\u0001\u0000"+ + "\u0000\u0000\u09a4k\u0001\u0000\u0000\u0000\u09a5\u09a9\u0005\u0098\u0000"+ + "\u0000\u09a6\u09a9\u0005\u0136\u0000\u0000\u09a7\u09a9\u0001\u0000\u0000"+ + "\u0000\u09a8\u09a5\u0001\u0000\u0000\u0000\u09a8\u09a6\u0001\u0000\u0000"+ + "\u0000\u09a8\u09a7\u0001\u0000\u0000\u0000\u09a9m\u0001\u0000\u0000\u0000"+ + "\u09aa\u09ab\u0005-\u0000\u0000\u09ab\u09ae\u0003\u020c\u0106\u0000\u09ac"+ + "\u09ae\u0001\u0000\u0000\u0000\u09ad\u09aa\u0001\u0000\u0000\u0000\u09ad"+ + "\u09ac\u0001\u0000\u0000\u0000\u09aeo\u0001\u0000\u0000\u0000\u09af\u09b0"+ + "\u0005f\u0000\u0000\u09b0\u09b3\u0003\u048c\u0246\u0000\u09b1\u09b3\u0001"+ + "\u0000\u0000\u0000\u09b2\u09af\u0001\u0000\u0000\u0000\u09b2\u09b1\u0001"+ + "\u0000\u0000\u0000\u09b3q\u0001\u0000\u0000\u0000\u09b4\u09bb\u0005\u0109"+ + "\u0000\u0000\u09b5\u09bb\u0005s\u0000\u0000\u09b6\u09bb\u00057\u0000\u0000"+ + "\u09b7\u09b8\u0005f\u0000\u0000\u09b8\u09b9\u0005\u00e4\u0000\u0000\u09b9"+ + "\u09bb\u0003\u053c\u029e\u0000\u09ba\u09b4\u0001\u0000\u0000\u0000\u09ba"+ + "\u09b5\u0001\u0000\u0000\u0000\u09ba\u09b6\u0001\u0000\u0000\u0000\u09ba"+ + "\u09b7\u0001\u0000\u0000\u0000\u09bbs\u0001\u0000\u0000\u0000\u09bc\u09bd"+ + "\u0005\u0003\u0000\u0000\u09bd\u09be\u0003x<\u0000\u09be\u09bf\u0005\u0004"+ + "\u0000\u0000\u09bfu\u0001\u0000\u0000\u0000\u09c0\u09c1\u0005k\u0000\u0000"+ + "\u09c1\u09c4\u0003t:\u0000\u09c2\u09c4\u0001\u0000\u0000\u0000\u09c3\u09c0"+ + "\u0001\u0000\u0000\u0000\u09c3\u09c2\u0001\u0000\u0000\u0000\u09c4w\u0001"+ + "\u0000\u0000\u0000\u09c5\u09ca\u0003z=\u0000\u09c6\u09c7\u0005\u0007\u0000"+ + "\u0000\u09c7\u09c9\u0003z=\u0000\u09c8\u09c6\u0001\u0000\u0000\u0000\u09c9"+ + "\u09cc\u0001\u0000\u0000\u0000\u09ca\u09c8\u0001\u0000\u0000\u0000\u09ca"+ + "\u09cb\u0001\u0000\u0000\u0000\u09cby\u0001\u0000\u0000\u0000\u09cc\u09ca"+ + "\u0001\u0000\u0000\u0000\u09cd\u09d6\u0003\u0564\u02b2\u0000\u09ce\u09cf"+ + "\u0005\f\u0000\u0000\u09cf\u09d7\u0003\u01d2\u00e9\u0000\u09d0\u09d1\u0005"+ + "\r\u0000\u0000\u09d1\u09d4\u0003\u0564\u02b2\u0000\u09d2\u09d3\u0005\f"+ + "\u0000\u0000\u09d3\u09d5\u0003\u01d2\u00e9\u0000\u09d4\u09d2\u0001\u0000"+ + "\u0000\u0000\u09d4\u09d5\u0001\u0000\u0000\u0000\u09d5\u09d7\u0001\u0000"+ + "\u0000\u0000\u09d6\u09ce\u0001\u0000\u0000\u0000\u09d6\u09d0\u0001\u0000"+ + "\u0000\u0000\u09d6\u09d7\u0001\u0000\u0000\u0000\u09d7{\u0001\u0000\u0000"+ + "\u0000\u09d8\u09da\u0003~?\u0000\u09d9\u09d8\u0001\u0000\u0000\u0000\u09da"+ + "\u09db\u0001\u0000\u0000\u0000\u09db\u09d9\u0001\u0000\u0000\u0000\u09db"+ + "\u09dc\u0001\u0000\u0000\u0000\u09dc}\u0001\u0000\u0000\u0000\u09dd\u09e1"+ + "\u0005\u0135\u0000\u0000\u09de\u09df\u0003\u0010\b\u0000\u09df\u09e0\u0003"+ + "\u0124\u0092\u0000\u09e0\u09e2\u0001\u0000\u0000\u0000\u09e1\u09de\u0001"+ + "\u0000\u0000\u0000\u09e1\u09e2\u0001\u0000\u0000\u0000\u09e2\u09ea\u0001"+ + "\u0000\u0000\u0000\u09e3\u09e7\u0005\u0148\u0000\u0000\u09e4\u09e8\u0003"+ + "\u0120\u0090\u0000\u09e5\u09e6\u0005\u01b8\u0000\u0000\u09e6\u09e8\u0003"+ + "\u00c6c\u0000\u09e7\u09e4\u0001\u0000\u0000\u0000\u09e7\u09e5\u0001\u0000"+ + "\u0000\u0000\u09e8\u09ea\u0001\u0000\u0000\u0000\u09e9\u09dd\u0001\u0000"+ + "\u0000\u0000\u09e9\u09e3\u0001\u0000\u0000\u0000\u09ea\u007f\u0001\u0000"+ + "\u0000\u0000\u09eb\u09ec\u0005@\u0000\u0000\u09ec\u09ed\u0005\u01a1\u0000"+ + "\u0000\u09ed\u09ee\u0005k\u0000\u0000\u09ee\u09ef\u0005\u0003\u0000\u0000"+ + "\u09ef\u09f0\u0003\u0084B\u0000\u09f0\u09f1\u0005\u0004\u0000\u0000\u09f1"+ + "\u0a06\u0001\u0000\u0000\u0000\u09f2\u09f3\u0005@\u0000\u0000\u09f3\u09f4"+ + "\u0005\u01a1\u0000\u0000\u09f4\u09f5\u0005F\u0000\u0000\u09f5\u09f6\u0005"+ + "\u0003\u0000\u0000\u09f6\u09f7\u0003\u0500\u0280\u0000\u09f7\u09f8\u0005"+ + "\u0004\u0000\u0000\u09f8\u0a06\u0001\u0000\u0000\u0000\u09f9\u09fa\u0005"+ + "@\u0000\u0000\u09fa\u09fb\u0005\u01a1\u0000\u0000\u09fb\u09fc\u0005B\u0000"+ + "\u0000\u09fc\u09fd\u0005\u0003\u0000\u0000\u09fd\u09fe\u0003\u0500\u0280"+ + "\u0000\u09fe\u09ff\u0005\u0004\u0000\u0000\u09ff\u0a00\u0005`\u0000\u0000"+ + "\u0a00\u0a01\u0005\u0003\u0000\u0000\u0a01\u0a02\u0003\u0500\u0280\u0000"+ + "\u0a02\u0a03\u0005\u0004\u0000\u0000\u0a03\u0a06\u0001\u0000\u0000\u0000"+ + "\u0a04\u0a06\u00057\u0000\u0000\u0a05\u09eb\u0001\u0000\u0000\u0000\u0a05"+ + "\u09f2\u0001\u0000\u0000\u0000\u0a05\u09f9\u0001\u0000\u0000\u0000\u0a05"+ + "\u0a04\u0001\u0000\u0000\u0000\u0a06\u0081\u0001\u0000\u0000\u0000\u0a07"+ + "\u0a08\u0003\u0562\u02b1\u0000\u0a08\u0a09\u0003\u054c\u02a6\u0000\u0a09"+ + "\u0083\u0001\u0000\u0000\u0000\u0a0a\u0a0f\u0003\u0082A\u0000\u0a0b\u0a0c"+ + "\u0005\u0007\u0000\u0000\u0a0c\u0a0e\u0003\u0082A\u0000\u0a0d\u0a0b\u0001"+ + "\u0000\u0000\u0000\u0a0e\u0a11\u0001\u0000\u0000\u0000\u0a0f\u0a0d\u0001"+ + "\u0000\u0000\u0000\u0a0f\u0a10\u0001\u0000\u0000\u0000\u0a10\u0085\u0001"+ + "\u0000\u0000\u0000\u0a11\u0a0f\u0001\u0000\u0000\u0000\u0a12\u0a13\u0005"+ + "\u008c\u0000\u0000\u0a13\u0a14\u0005\u0163\u0000\u0000\u0a14\u0a15\u0003"+ + "\u020c\u0106\u0000\u0a15\u0a16\u0003\u0088D\u0000\u0a16\u0087\u0001\u0000"+ + "\u0000\u0000\u0a17\u0a1c\u0003\u008aE\u0000\u0a18\u0a19\u0005\u0007\u0000"+ + "\u0000\u0a19\u0a1b\u0003\u008aE\u0000\u0a1a\u0a18\u0001\u0000\u0000\u0000"+ + "\u0a1b\u0a1e\u0001\u0000\u0000\u0000\u0a1c\u0a1a\u0001\u0000\u0000\u0000"+ + "\u0a1c\u0a1d\u0001\u0000\u0000\u0000\u0a1d\u0089\u0001\u0000\u0000\u0000"+ + "\u0a1e\u0a1c\u0001\u0000\u0000\u0000\u0a1f\u0a20\u0005\u0087\u0000\u0000"+ + "\u0a20\u0a21\u0005\u0091\u0000\u0000\u0a21\u0a22\u0003\u0450\u0228\u0000"+ + "\u0a22\u0a23\u0003l6\u0000\u0a23\u0a37\u0001\u0000\u0000\u0000\u0a24\u0a25"+ + "\u0005\u00c1\u0000\u0000\u0a25\u0a28\u0005\u0091\u0000\u0000\u0a26\u0a27"+ + "\u0005\u00de\u0000\u0000\u0a27\u0a29\u0005\u0187\u0000\u0000\u0a28\u0a26"+ + "\u0001\u0000\u0000\u0000\u0a28\u0a29\u0001\u0000\u0000\u0000\u0a29\u0a2a"+ + "\u0001\u0000\u0000\u0000\u0a2a\u0a2b\u0003\u055c\u02ae\u0000\u0a2b\u0a2c"+ + "\u0003l6\u0000\u0a2c\u0a37\u0001\u0000\u0000\u0000\u0a2d\u0a2e\u0005\u008c"+ + "\u0000\u0000\u0a2e\u0a2f\u0005\u0091\u0000\u0000\u0a2f\u0a30\u0003\u055c"+ + "\u02ae\u0000\u0a30\u0a31\u0003\u02d6\u016b\u0000\u0a31\u0a32\u0005\u0163"+ + "\u0000\u0000\u0a32\u0a33\u0003\u0460\u0230\u0000\u0a33\u0a34\u0003n7\u0000"+ + "\u0a34\u0a35\u0003l6\u0000\u0a35\u0a37\u0001\u0000\u0000\u0000\u0a36\u0a1f"+ + "\u0001\u0000\u0000\u0000\u0a36\u0a24\u0001\u0000\u0000\u0000\u0a36\u0a2d"+ + "\u0001\u0000\u0000\u0000\u0a37\u008b\u0001\u0000\u0000\u0000\u0a38\u0a3b"+ + "\u0005\u009f\u0000\u0000\u0a39\u0a3c\u0003\u03ba\u01dd\u0000\u0a3a\u0a3c"+ + "\u0005 \u0000\u0000\u0a3b\u0a39\u0001\u0000\u0000\u0000\u0a3b\u0a3a\u0001"+ + "\u0000\u0000\u0000\u0a3c\u008d\u0001\u0000\u0000\u0000\u0a3d\u0a3e\u0005"+ + "\u00ab\u0000\u0000\u0a3e\u0a3f\u0003\u009cN\u0000\u0a3f\u0a40\u0003\u0538"+ + "\u029c\u0000\u0a40\u0a41\u0003\u00d6k\u0000\u0a41\u0a42\u0003\u0090H\u0000"+ + "\u0a42\u0a43\u0003\u0092I\u0000\u0a43\u0a44\u0003\u0094J\u0000\u0a44\u0a45"+ + "\u0003\u009eO\u0000\u0a45\u0a46\u0003\u0010\b\u0000\u0a46\u0a47\u0003"+ + "\u0096K\u0000\u0a47\u0a48\u0003\u0448\u0224\u0000\u0a48\u0a54\u0001\u0000"+ + "\u0000\u0000\u0a49\u0a4a\u0005\u00ab\u0000\u0000\u0a4a\u0a4b\u0005\u0003"+ + "\u0000\u0000\u0a4b\u0a4c\u0003\u037e\u01bf\u0000\u0a4c\u0a4d\u0005\u0004"+ + "\u0000\u0000\u0a4d\u0a4e\u0005`\u0000\u0000\u0a4e\u0a4f\u0003\u0092I\u0000"+ + "\u0a4f\u0a50\u0003\u0094J\u0000\u0a50\u0a51\u0003\u0010\b\u0000\u0a51"+ + "\u0a52\u0003\u0096K\u0000\u0a52\u0a54\u0001\u0000\u0000\u0000\u0a53\u0a3d"+ + "\u0001\u0000\u0000\u0000\u0a53\u0a49\u0001\u0000\u0000\u0000\u0a54\u008f"+ + "\u0001\u0000\u0000\u0000\u0a55\u0a56\u0007\n\u0000\u0000\u0a56\u0091\u0001"+ + "\u0000\u0000\u0000\u0a57\u0a5a\u0005\u0124\u0000\u0000\u0a58\u0a5a\u0001"+ + "\u0000\u0000\u0000\u0a59\u0a57\u0001\u0000\u0000\u0000\u0a59\u0a58\u0001"+ + "\u0000\u0000\u0000\u0a5a\u0093\u0001\u0000\u0000\u0000\u0a5b\u0a5f\u0003"+ + "\u054e\u02a7\u0000\u0a5c\u0a5f\u0005\u0152\u0000\u0000\u0a5d\u0a5f\u0005"+ + "\u0153\u0000\u0000\u0a5e\u0a5b\u0001\u0000\u0000\u0000\u0a5e\u0a5c\u0001"+ + "\u0000\u0000\u0000\u0a5e\u0a5d\u0001\u0000\u0000\u0000\u0a5f\u0095\u0001"+ + "\u0000\u0000\u0000\u0a60\u0a66\u0003\u0098L\u0000\u0a61\u0a62\u0005\u0003"+ + "\u0000\u0000\u0a62\u0a63\u0003\u00a2Q\u0000\u0a63\u0a64\u0005\u0004\u0000"+ + "\u0000\u0a64\u0a66\u0001\u0000\u0000\u0000\u0a65\u0a60\u0001\u0000\u0000"+ + "\u0000\u0a65\u0a61\u0001\u0000\u0000\u0000\u0a66\u0097\u0001\u0000\u0000"+ + "\u0000\u0a67\u0a69\u0003\u009aM\u0000\u0a68\u0a67\u0001\u0000\u0000\u0000"+ + "\u0a69\u0a6c\u0001\u0000\u0000\u0000\u0a6a\u0a68\u0001\u0000\u0000\u0000"+ + "\u0a6a\u0a6b\u0001\u0000\u0000\u0000\u0a6b\u0099\u0001\u0000\u0000\u0000"+ + "\u0a6c\u0a6a\u0001\u0000\u0000\u0000\u0a6d\u0a91\u0005m\u0000\u0000\u0a6e"+ + "\u0a91\u0005r\u0000\u0000\u0a6f\u0a70\u0005\u00b9\u0000\u0000\u0a70\u0a71"+ + "\u0003\u0342\u01a1\u0000\u0a71\u0a72\u0003\u054e\u02a7\u0000\u0a72\u0a91"+ + "\u0001\u0000\u0000\u0000\u0a73\u0a74\u0005P\u0000\u0000\u0a74\u0a75\u0003"+ + "\u0342\u01a1\u0000\u0a75\u0a76\u0003\u054e\u02a7\u0000\u0a76\u0a91\u0001"+ + "\u0000\u0000\u0000\u0a77\u0a91\u0005\u00ad\u0000\u0000\u0a78\u0a91\u0005"+ + "\u00da\u0000\u0000\u0a79\u0a7a\u0005\u0125\u0000\u0000\u0a7a\u0a7b\u0003"+ + "\u0342\u01a1\u0000\u0a7b\u0a7c\u0003\u054e\u02a7\u0000\u0a7c\u0a91\u0001"+ + "\u0000\u0000\u0000\u0a7d\u0a7e\u0005\u00c7\u0000\u0000\u0a7e\u0a7f\u0003"+ + "\u0342\u01a1\u0000\u0a7f\u0a80\u0003\u054e\u02a7\u0000\u0a80\u0a91\u0001"+ + "\u0000\u0000\u0000\u0a81\u0a82\u0005\u00d3\u0000\u0000\u0a82\u0a83\u0005"+ + "\u0125\u0000\u0000\u0a83\u0a91\u0003\u00d8l\u0000\u0a84\u0a85\u0005\u00d3"+ + "\u0000\u0000\u0a85\u0a86\u0005\u0125\u0000\u0000\u0a86\u0a91\u0005\u000b"+ + "\u0000\u0000\u0a87\u0a88\u0005\u00d3\u0000\u0000\u0a88\u0a89\u0005O\u0000"+ + "\u0000\u0a89\u0a8a\u0005P\u0000\u0000\u0a8a\u0a91\u0003\u00d8l\u0000\u0a8b"+ + "\u0a8c\u0005\u00d3\u0000\u0000\u0a8c\u0a8d\u0005P\u0000\u0000\u0a8d\u0a91"+ + "\u0003\u00d8l\u0000\u0a8e\u0a8f\u0005\u00c4\u0000\u0000\u0a8f\u0a91\u0003"+ + "\u054e\u02a7\u0000\u0a90\u0a6d\u0001\u0000\u0000\u0000\u0a90\u0a6e\u0001"+ + "\u0000\u0000\u0000\u0a90\u0a6f\u0001\u0000\u0000\u0000\u0a90\u0a73\u0001"+ + "\u0000\u0000\u0000\u0a90\u0a77\u0001\u0000\u0000\u0000\u0a90\u0a78\u0001"+ + "\u0000\u0000\u0000\u0a90\u0a79\u0001\u0000\u0000\u0000\u0a90\u0a7d\u0001"+ + "\u0000\u0000\u0000\u0a90\u0a81\u0001\u0000\u0000\u0000\u0a90\u0a84\u0001"+ + "\u0000\u0000\u0000\u0a90\u0a87\u0001\u0000\u0000\u0000\u0a90\u0a8b\u0001"+ + "\u0000\u0000\u0000\u0a90\u0a8e\u0001\u0000\u0000\u0000\u0a91\u009b\u0001"+ + "\u0000\u0000\u0000\u0a92\u0a95\u0005m\u0000\u0000\u0a93\u0a95\u0001\u0000"+ + "\u0000\u0000\u0a94\u0a92\u0001\u0000\u0000\u0000\u0a94\u0a93\u0001\u0000"+ + "\u0000\u0000\u0a95\u009d\u0001\u0000\u0000\u0000\u0a96\u0a97\u0003\u00a0"+ + "P\u0000\u0a97\u0a98\u0005\u00ba\u0000\u0000\u0a98\u0a99\u0003\u054e\u02a7"+ + "\u0000\u0a99\u0a9c\u0001\u0000\u0000\u0000\u0a9a\u0a9c\u0001\u0000\u0000"+ + "\u0000\u0a9b\u0a96\u0001\u0000\u0000\u0000\u0a9b\u0a9a\u0001\u0000\u0000"+ + "\u0000\u0a9c\u009f\u0001\u0000\u0000\u0000\u0a9d\u0aa0\u0005f\u0000\u0000"+ + "\u0a9e\u0aa0\u0001\u0000\u0000\u0000\u0a9f\u0a9d\u0001\u0000\u0000\u0000"+ + "\u0a9f\u0a9e\u0001\u0000\u0000\u0000\u0aa0\u00a1\u0001\u0000\u0000\u0000"+ + "\u0aa1\u0aa6\u0003\u00a4R\u0000\u0aa2\u0aa3\u0005\u0007\u0000\u0000\u0aa3"+ + "\u0aa5\u0003\u00a4R\u0000\u0aa4\u0aa2\u0001\u0000\u0000\u0000\u0aa5\u0aa8"+ + "\u0001\u0000\u0000\u0000\u0aa6\u0aa4\u0001\u0000\u0000\u0000\u0aa6\u0aa7"+ + "\u0001\u0000\u0000\u0000\u0aa7\u00a3\u0001\u0000\u0000\u0000\u0aa8\u0aa6"+ + "\u0001\u0000\u0000\u0000\u0aa9\u0aaa\u0003\u0564\u02b2\u0000\u0aaa\u0aab"+ + "\u0003\u00a6S\u0000\u0aab\u00a5\u0001\u0000\u0000\u0000\u0aac\u0ab5\u0003"+ + "B!\u0000\u0aad\u0ab5\u0003\u0124\u0092\u0000\u0aae\u0ab5\u0005\u000b\u0000"+ + "\u0000\u0aaf\u0ab0\u0005\u0003\u0000\u0000\u0ab0\u0ab1\u0003\u00a8T\u0000"+ + "\u0ab1\u0ab2\u0005\u0004\u0000\u0000\u0ab2\u0ab5\u0001\u0000\u0000\u0000"+ + "\u0ab3\u0ab5\u0001\u0000\u0000\u0000\u0ab4\u0aac\u0001\u0000\u0000\u0000"+ + "\u0ab4\u0aad\u0001\u0000\u0000\u0000\u0ab4\u0aae\u0001\u0000\u0000\u0000"+ + "\u0ab4\u0aaf\u0001\u0000\u0000\u0000\u0ab4\u0ab3\u0001\u0000\u0000\u0000"+ + "\u0ab5\u00a7\u0001\u0000\u0000\u0000\u0ab6\u0abb\u0003\u00aaU\u0000\u0ab7"+ + "\u0ab8\u0005\u0007\u0000\u0000\u0ab8\u0aba\u0003\u00aaU\u0000\u0ab9\u0ab7"+ + "\u0001\u0000\u0000\u0000\u0aba\u0abd\u0001\u0000\u0000\u0000\u0abb\u0ab9"+ + "\u0001\u0000\u0000\u0000\u0abb\u0abc\u0001\u0000\u0000\u0000\u0abc\u00a9"+ + "\u0001\u0000\u0000\u0000\u0abd\u0abb\u0001\u0000\u0000\u0000\u0abe\u0abf"+ + "\u0003B!\u0000\u0abf\u00ab\u0001\u0000\u0000\u0000\u0ac0\u0ac1\u00050"+ + "\u0000\u0000\u0ac1\u0ac2\u0003\u00aeW\u0000\u0ac2\u0ac6\u0005^\u0000\u0000"+ + "\u0ac3\u0ac4\u0005\u00de\u0000\u0000\u0ac4\u0ac5\u0005O\u0000\u0000\u0ac5"+ + "\u0ac7\u0005\u0187\u0000\u0000\u0ac6\u0ac3\u0001\u0000\u0000\u0000\u0ac6"+ + "\u0ac7\u0001\u0000\u0000\u0000\u0ac7\u0ac8\u0001\u0000\u0000\u0000\u0ac8"+ + "\u0ae7\u0003\u0538\u029c\u0000\u0ac9\u0aca\u0005\u0003\u0000\u0000\u0aca"+ + "\u0acb\u0003\u00b0X\u0000\u0acb\u0acc\u0005\u0004\u0000\u0000\u0acc\u0acd"+ + "\u0003\u00eew\u0000\u0acd\u0ace\u0003\u00f0x\u0000\u0ace\u0acf\u0003\u00f8"+ + "|\u0000\u0acf\u0ad0\u0003\u00fa}\u0000\u0ad0\u0ad1\u0003\u00fc~\u0000"+ + "\u0ad1\u0ad2\u0003\u00fe\u007f\u0000\u0ad2\u0ae8\u0001\u0000\u0000\u0000"+ + "\u0ad3\u0ad4\u0005\u010e\u0000\u0000\u0ad4\u0ad5\u0003\u020c\u0106\u0000"+ + "\u0ad5\u0ad6\u0003\u00b2Y\u0000\u0ad6\u0ad7\u0003\u00f0x\u0000\u0ad7\u0ad8"+ + "\u0003\u00f8|\u0000\u0ad8\u0ad9\u0003\u00fa}\u0000\u0ad9\u0ada\u0003\u00fc"+ + "~\u0000\u0ada\u0adb\u0003\u00fe\u007f\u0000\u0adb\u0ae8\u0001\u0000\u0000"+ + "\u0000\u0adc\u0add\u0005\u0118\u0000\u0000\u0add\u0ade\u0005\u010e\u0000"+ + "\u0000\u0ade\u0adf\u0003\u0538\u029c\u0000\u0adf\u0ae0\u0003\u00b2Y\u0000"+ + "\u0ae0\u0ae1\u0003\u0080@\u0000\u0ae1\u0ae2\u0003\u00f0x\u0000\u0ae2\u0ae3"+ + "\u0003\u00f8|\u0000\u0ae3\u0ae4\u0003\u00fa}\u0000\u0ae4\u0ae5\u0003\u00fc"+ + "~\u0000\u0ae5\u0ae6\u0003\u00fe\u007f\u0000\u0ae6\u0ae8\u0001\u0000\u0000"+ + "\u0000\u0ae7\u0ac9\u0001\u0000\u0000\u0000\u0ae7\u0ad3\u0001\u0000\u0000"+ + "\u0000\u0ae7\u0adc\u0001\u0000\u0000\u0000\u0ae8\u00ad\u0001\u0000\u0000"+ + "\u0000\u0ae9\u0af2\u0005\u015d\u0000\u0000\u0aea\u0af2\u0005\u015b\u0000"+ + "\u0000\u0aeb\u0aec\u0005\u00f7\u0000\u0000\u0aec\u0af2\u0007\u000b\u0000"+ + "\u0000\u0aed\u0aee\u0005\u00d7\u0000\u0000\u0aee\u0af2\u0007\u000b\u0000"+ + "\u0000\u0aef\u0af2\u0005\u016a\u0000\u0000\u0af0\u0af2\u0001\u0000\u0000"+ + "\u0000\u0af1\u0ae9\u0001\u0000\u0000\u0000\u0af1\u0aea\u0001\u0000\u0000"+ + "\u0000\u0af1\u0aeb\u0001\u0000\u0000\u0000\u0af1\u0aed\u0001\u0000\u0000"+ + "\u0000\u0af1\u0aef\u0001\u0000\u0000\u0000\u0af1\u0af0\u0001\u0000\u0000"+ + "\u0000\u0af2\u00af\u0001\u0000\u0000\u0000\u0af3\u0af6\u0003\u00b4Z\u0000"+ + "\u0af4\u0af6\u0001\u0000\u0000\u0000\u0af5\u0af3\u0001\u0000\u0000\u0000"+ + "\u0af5\u0af4\u0001\u0000\u0000\u0000\u0af6\u00b1\u0001\u0000\u0000\u0000"+ + "\u0af7\u0af8\u0005\u0003\u0000\u0000\u0af8\u0af9\u0003\u00b6[\u0000\u0af9"+ + "\u0afa\u0005\u0004\u0000\u0000\u0afa\u0afd\u0001\u0000\u0000\u0000\u0afb"+ + "\u0afd\u0001\u0000\u0000\u0000\u0afc\u0af7\u0001\u0000\u0000\u0000\u0afc"+ + "\u0afb\u0001\u0000\u0000\u0000\u0afd\u00b3\u0001\u0000\u0000\u0000\u0afe"+ + "\u0b03\u0003\u00b8\\\u0000\u0aff\u0b00\u0005\u0007\u0000\u0000\u0b00\u0b02"+ + "\u0003\u00b8\\\u0000\u0b01\u0aff\u0001\u0000\u0000\u0000\u0b02\u0b05\u0001"+ + "\u0000\u0000\u0000\u0b03\u0b01\u0001\u0000\u0000\u0000\u0b03\u0b04\u0001"+ + "\u0000\u0000\u0000\u0b04\u00b5\u0001\u0000\u0000\u0000\u0b05\u0b03\u0001"+ + "\u0000\u0000\u0000\u0b06\u0b0b\u0003\u00ba]\u0000\u0b07\u0b08\u0005\u0007"+ + "\u0000\u0000\u0b08\u0b0a\u0003\u00ba]\u0000\u0b09\u0b07\u0001\u0000\u0000"+ + "\u0000\u0b0a\u0b0d\u0001\u0000\u0000\u0000\u0b0b\u0b09\u0001\u0000\u0000"+ + "\u0000\u0b0b\u0b0c\u0001\u0000\u0000\u0000\u0b0c\u00b7\u0001\u0000\u0000"+ + "\u0000\u0b0d\u0b0b\u0001\u0000\u0000\u0000\u0b0e\u0b12\u0003\u00d0h\u0000"+ + "\u0b0f\u0b12\u0003\u00cae\u0000\u0b10\u0b12\u0003\u00bc^\u0000\u0b11\u0b0e"+ + "\u0001\u0000\u0000\u0000\u0b11\u0b0f\u0001\u0000\u0000\u0000\u0b11\u0b10"+ + "\u0001\u0000\u0000\u0000\u0b12\u00b9\u0001\u0000\u0000\u0000\u0b13\u0b16"+ + "\u0003\u00be_\u0000\u0b14\u0b16\u0003\u00d0h\u0000\u0b15\u0b13\u0001\u0000"+ + "\u0000\u0000\u0b15\u0b14\u0001\u0000\u0000\u0000\u0b16\u00bb\u0001\u0000"+ + "\u0000\u0000\u0b17\u0b18\u0003\u055c\u02ae\u0000\u0b18\u0b19\u0003\u0460"+ + "\u0230\u0000\u0b19\u0b1a\u0003\u0154\u00aa\u0000\u0b1a\u0b1b\u0003\u00c0"+ + "`\u0000\u0b1b\u00bd\u0001\u0000\u0000\u0000\u0b1c\u0b1f\u0003\u055c\u02ae"+ + "\u0000\u0b1d\u0b1e\u0005k\u0000\u0000\u0b1e\u0b20\u0005\u0113\u0000\u0000"+ + "\u0b1f\u0b1d\u0001\u0000\u0000\u0000\u0b1f\u0b20\u0001\u0000\u0000\u0000"+ + "\u0b20\u0b21\u0001\u0000\u0000\u0000\u0b21\u0b22\u0003\u00c0`\u0000\u0b22"+ + "\u00bf\u0001\u0000\u0000\u0000\u0b23\u0b25\u0003\u00c2a\u0000\u0b24\u0b23"+ + "\u0001\u0000\u0000\u0000\u0b25\u0b28\u0001\u0000\u0000\u0000\u0b26\u0b24"+ + "\u0001\u0000\u0000\u0000\u0b26\u0b27\u0001\u0000\u0000\u0000\u0b27\u00c1"+ + "\u0001\u0000\u0000\u0000\u0b28\u0b26\u0001\u0000\u0000\u0000\u0b29\u0b2a"+ + "\u0005/\u0000\u0000\u0b2a\u0b2b\u0003\u053c\u029e\u0000\u0b2b\u0b2c\u0003"+ + "\u00c4b\u0000\u0b2c\u0b32\u0001\u0000\u0000\u0000\u0b2d\u0b32\u0003\u00c4"+ + "b\u0000\u0b2e\u0b32\u0003\u00c8d\u0000\u0b2f\u0b30\u0005-\u0000\u0000"+ + "\u0b30\u0b32\u0003\u020c\u0106\u0000\u0b31\u0b29\u0001\u0000\u0000\u0000"+ + "\u0b31\u0b2d\u0001\u0000\u0000\u0000\u0b31\u0b2e\u0001\u0000\u0000\u0000"+ + "\u0b31\u0b2f\u0001\u0000\u0000\u0000\u0b32\u00c3\u0001\u0000\u0000\u0000"+ + "\u0b33\u0b34\u0005O\u0000\u0000\u0b34\u0b5a\u0005P\u0000\u0000\u0b35\u0b5a"+ + "\u0005P\u0000\u0000\u0b36\u0b37\u0005d\u0000\u0000\u0b37\u0b38\u0003\u0298"+ + "\u014c\u0000\u0b38\u0b39\u0003\u0100\u0080\u0000\u0b39\u0b5a\u0001\u0000"+ + "\u0000\u0000\u0b3a\u0b3b\u0005W\u0000\u0000\u0b3b\u0b3c\u0005\u00ee\u0000"+ + "\u0000\u0b3c\u0b3d\u0003\u0298\u014c\u0000\u0b3d\u0b3e\u0003\u0100\u0080"+ + "\u0000\u0b3e\u0b5a\u0001\u0000\u0000\u0000\u0b3f\u0b40\u0005,\u0000\u0000"+ + "\u0b40\u0b41\u0005\u0003\u0000\u0000\u0b41\u0b42\u0003\u048c\u0246\u0000"+ + "\u0b42\u0b43\u0005\u0004\u0000\u0000\u0b43\u0b44\u0003\u00d4j\u0000\u0b44"+ + "\u0b5a\u0001\u0000\u0000\u0000\u0b45\u0b46\u00057\u0000\u0000\u0b46\u0b5a"+ + "\u0003\u04b6\u025b\u0000\u0b47\u0b48\u0005\u01b8\u0000\u0000\u0b48\u0b49"+ + "\u0003\u00c6c\u0000\u0b49\u0b51\u0005&\u0000\u0000\u0b4a\u0b4b\u0005\u00dd"+ + "\u0000\u0000\u0b4b\u0b52\u0003\u011c\u008e\u0000\u0b4c\u0b4d\u0005\u0003"+ + "\u0000\u0000\u0b4d\u0b4e\u0003\u048c\u0246\u0000\u0b4e\u0b4f\u0005\u0004"+ + "\u0000\u0000\u0b4f\u0b50\u0005\u01ba\u0000\u0000\u0b50\u0b52\u0001\u0000"+ + "\u0000\u0000\u0b51\u0b4a\u0001\u0000\u0000\u0000\u0b51\u0b4c\u0001\u0000"+ + "\u0000\u0000\u0b52\u0b5a\u0001\u0000\u0000\u0000\u0b53\u0b54\u0005X\u0000"+ + "\u0000\u0b54\u0b55\u0003\u0538\u029c\u0000\u0b55\u0b56\u0003\u00d6k\u0000"+ + "\u0b56\u0b57\u0003\u00deo\u0000\u0b57\u0b58\u0003\u00e6s\u0000\u0b58\u0b5a"+ + "\u0001\u0000\u0000\u0000\u0b59\u0b33\u0001\u0000\u0000\u0000\u0b59\u0b35"+ + "\u0001\u0000\u0000\u0000\u0b59\u0b36\u0001\u0000\u0000\u0000\u0b59\u0b3a"+ + "\u0001\u0000\u0000\u0000\u0b59\u0b3f\u0001\u0000\u0000\u0000\u0b59\u0b45"+ + "\u0001\u0000\u0000\u0000\u0b59\u0b47\u0001\u0000\u0000\u0000\u0b59\u0b53"+ + "\u0001\u0000\u0000\u0000\u0b5a\u00c5\u0001\u0000\u0000\u0000\u0b5b\u0b5f"+ + "\u0005\u008d\u0000\u0000\u0b5c\u0b5d\u0005\u0095\u0000\u0000\u0b5d\u0b5f"+ + "\u00057\u0000\u0000\u0b5e\u0b5b\u0001\u0000\u0000\u0000\u0b5e\u0b5c\u0001"+ + "\u0000\u0000\u0000\u0b5f\u00c7\u0001\u0000\u0000\u0000\u0b60\u0b66\u0005"+ + "8\u0000\u0000\u0b61\u0b62\u0005O\u0000\u0000\u0b62\u0b66\u00058\u0000"+ + "\u0000\u0b63\u0b64\u0005G\u0000\u0000\u0b64\u0b66\u0007\b\u0000\u0000"+ + "\u0b65\u0b60\u0001\u0000\u0000\u0000\u0b65\u0b61\u0001\u0000\u0000\u0000"+ + "\u0b65\u0b63\u0001\u0000\u0000\u0000\u0b66\u00c9\u0001\u0000\u0000\u0000"+ + "\u0b67\u0b68\u0005z\u0000\u0000\u0b68\u0b69\u0003\u0538\u029c\u0000\u0b69"+ + "\u0b6a\u0003\u00ccf\u0000\u0b6a\u00cb\u0001\u0000\u0000\u0000\u0b6b\u0b6c"+ + "\u0007\f\u0000\u0000\u0b6c\u0b6e\u0003\u00ceg\u0000\u0b6d\u0b6b\u0001"+ + "\u0000\u0000\u0000\u0b6e\u0b71\u0001\u0000\u0000\u0000\u0b6f\u0b6d\u0001"+ + "\u0000\u0000\u0000\u0b6f\u0b70\u0001\u0000\u0000\u0000\u0b70\u00cd\u0001"+ + "\u0000\u0000\u0000\u0b71\u0b6f\u0001\u0000\u0000\u0000\u0b72\u0b73\u0007"+ + "\r\u0000\u0000\u0b73\u00cf\u0001\u0000\u0000\u0000\u0b74\u0b75\u0005/"+ + "\u0000\u0000\u0b75\u0b76\u0003\u053c\u029e\u0000\u0b76\u0b77\u0003\u00d2"+ + "i\u0000\u0b77\u0b7a\u0001\u0000\u0000\u0000\u0b78\u0b7a\u0003\u00d2i\u0000"+ + "\u0b79\u0b74\u0001\u0000\u0000\u0000\u0b79\u0b78\u0001\u0000\u0000\u0000"+ + "\u0b7a\u00d1\u0001\u0000\u0000\u0000\u0b7b\u0b7c\u0005,\u0000\u0000\u0b7c"+ + "\u0b7d\u0005\u0003\u0000\u0000\u0b7d\u0b7e\u0003\u048c\u0246\u0000\u0b7e"+ + "\u0b7f\u0005\u0004\u0000\u0000\u0b7f\u0b80\u0003\u01b8\u00dc\u0000\u0b80"+ + "\u0bb6\u0001\u0000\u0000\u0000\u0b81\u0b8d\u0005d\u0000\u0000\u0b82\u0b83"+ + "\u0005\u0003\u0000\u0000\u0b83\u0b84\u0003\u00d8l\u0000\u0b84\u0b85\u0005"+ + "\u0004\u0000\u0000\u0b85\u0b86\u0003\u00dcn\u0000\u0b86\u0b87\u0003\u0298"+ + "\u014c\u0000\u0b87\u0b88\u0003\u0100\u0080\u0000\u0b88\u0b89\u0003\u01b8"+ + "\u00dc\u0000\u0b89\u0b8e\u0001\u0000\u0000\u0000\u0b8a\u0b8b\u0003\u0102"+ + "\u0081\u0000\u0b8b\u0b8c\u0003\u01b8\u00dc\u0000\u0b8c\u0b8e\u0001\u0000"+ + "\u0000\u0000\u0b8d\u0b82\u0001\u0000\u0000\u0000\u0b8d\u0b8a\u0001\u0000"+ + "\u0000\u0000\u0b8e\u0bb6\u0001\u0000\u0000\u0000\u0b8f\u0b90\u0005W\u0000"+ + "\u0000\u0b90\u0b9c\u0005\u00ee\u0000\u0000\u0b91\u0b92\u0005\u0003\u0000"+ + "\u0000\u0b92\u0b93\u0003\u00d8l\u0000\u0b93\u0b94\u0005\u0004\u0000\u0000"+ + "\u0b94\u0b95\u0003\u00dcn\u0000\u0b95\u0b96\u0003\u0298\u014c\u0000\u0b96"+ + "\u0b97\u0003\u0100\u0080\u0000\u0b97\u0b98\u0003\u01b8\u00dc\u0000\u0b98"+ + "\u0b9d\u0001\u0000\u0000\u0000\u0b99\u0b9a\u0003\u0102\u0081\u0000\u0b9a"+ + "\u0b9b\u0003\u01b8\u00dc\u0000\u0b9b\u0b9d\u0001\u0000\u0000\u0000\u0b9c"+ + "\u0b91\u0001\u0000\u0000\u0000\u0b9c\u0b99\u0001\u0000\u0000\u0000\u0b9d"+ + "\u0bb6\u0001\u0000\u0000\u0000\u0b9e\u0b9f\u0005\u00c9\u0000\u0000\u0b9f"+ + "\u0ba0\u0003\u0254\u012a\u0000\u0ba0\u0ba1\u0005\u0003\u0000\u0000\u0ba1"+ + "\u0ba2\u0003\u00e0p\u0000\u0ba2\u0ba3\u0005\u0004\u0000\u0000\u0ba3\u0ba4"+ + "\u0003\u00dcn\u0000\u0ba4\u0ba5\u0003\u0298\u014c\u0000\u0ba5\u0ba6\u0003"+ + "\u0100\u0080\u0000\u0ba6\u0ba7\u0003\u00e4r\u0000\u0ba7\u0ba8\u0003\u01b8"+ + "\u00dc\u0000\u0ba8\u0bb6\u0001\u0000\u0000\u0000\u0ba9\u0baa\u0005A\u0000"+ + "\u0000\u0baa\u0bab\u0005\u00ee\u0000\u0000\u0bab\u0bac\u0005\u0003\u0000"+ + "\u0000\u0bac\u0bad\u0003\u00d8l\u0000\u0bad\u0bae\u0005\u0004\u0000\u0000"+ + "\u0bae\u0baf\u0005X\u0000\u0000\u0baf\u0bb0\u0003\u0538\u029c\u0000\u0bb0"+ + "\u0bb1\u0003\u00d6k\u0000\u0bb1\u0bb2\u0003\u00deo\u0000\u0bb2\u0bb3\u0003"+ + "\u00e6s\u0000\u0bb3\u0bb4\u0003\u01b8\u00dc\u0000\u0bb4\u0bb6\u0001\u0000"+ + "\u0000\u0000\u0bb5\u0b7b\u0001\u0000\u0000\u0000\u0bb5\u0b81\u0001\u0000"+ + "\u0000\u0000\u0bb5\u0b8f\u0001\u0000\u0000\u0000\u0bb5\u0b9e\u0001\u0000"+ + "\u0000\u0000\u0bb5\u0ba9\u0001\u0000\u0000\u0000\u0bb6\u00d3\u0001\u0000"+ + "\u0000\u0000\u0bb7\u0bb8\u0005\u0108\u0000\u0000\u0bb8\u0bbb\u0005\u00e6"+ + "\u0000\u0000\u0bb9\u0bbb\u0001\u0000\u0000\u0000\u0bba\u0bb7\u0001\u0000"+ + "\u0000\u0000\u0bba\u0bb9\u0001\u0000\u0000\u0000\u0bbb\u00d5\u0001\u0000"+ + "\u0000\u0000\u0bbc\u0bbd\u0005\u0003\u0000\u0000\u0bbd\u0bbe\u0003\u00d8"+ + "l\u0000\u0bbe\u0bbf\u0005\u0004\u0000\u0000\u0bbf\u0bc2\u0001\u0000\u0000"+ + "\u0000\u0bc0\u0bc2\u0001\u0000\u0000\u0000\u0bc1\u0bbc\u0001\u0000\u0000"+ + "\u0000\u0bc1\u0bc0\u0001\u0000\u0000\u0000\u0bc2\u00d7\u0001\u0000\u0000"+ + "\u0000\u0bc3\u0bc8\u0003\u00dam\u0000\u0bc4\u0bc5\u0005\u0007\u0000\u0000"+ + "\u0bc5\u0bc7\u0003\u00dam\u0000\u0bc6\u0bc4\u0001\u0000\u0000\u0000\u0bc7"+ + "\u0bca\u0001\u0000\u0000\u0000\u0bc8\u0bc6\u0001\u0000\u0000\u0000\u0bc8"+ + "\u0bc9\u0001\u0000\u0000\u0000\u0bc9\u00d9\u0001\u0000\u0000\u0000\u0bca"+ + "\u0bc8\u0001\u0000\u0000\u0000\u0bcb\u0bcc\u0003\u055c\u02ae\u0000\u0bcc"+ + "\u00db\u0001\u0000\u0000\u0000\u0bcd\u0bce\u0005\u01bb\u0000\u0000\u0bce"+ + "\u0bcf\u0005\u0003\u0000\u0000\u0bcf\u0bd0\u0003\u00d8l\u0000\u0bd0\u0bd1"+ + "\u0005\u0004\u0000\u0000\u0bd1\u0bd4\u0001\u0000\u0000\u0000\u0bd2\u0bd4"+ + "\u0001\u0000\u0000\u0000\u0bd3\u0bcd\u0001\u0000\u0000\u0000\u0bd3\u0bd2"+ + "\u0001\u0000\u0000\u0000\u0bd4\u00dd\u0001\u0000\u0000\u0000\u0bd5\u0bd6"+ + "\u0005\u00fb\u0000\u0000\u0bd6\u0bd9\u0007\u000e\u0000\u0000\u0bd7\u0bd9"+ + "\u0001\u0000\u0000\u0000\u0bd8\u0bd5\u0001\u0000\u0000\u0000\u0bd8\u0bd7"+ + "\u0001\u0000\u0000\u0000\u0bd9\u00df\u0001\u0000\u0000\u0000\u0bda\u0bdf"+ + "\u0003\u00e2q\u0000\u0bdb\u0bdc\u0005\u0007\u0000\u0000\u0bdc\u0bde\u0003"+ + "\u00e2q\u0000\u0bdd\u0bdb\u0001\u0000\u0000\u0000\u0bde\u0be1\u0001\u0000"+ + "\u0000\u0000\u0bdf\u0bdd\u0001\u0000\u0000\u0000\u0bdf\u0be0\u0001\u0000"+ + "\u0000\u0000\u0be0\u00e1\u0001\u0000\u0000\u0000\u0be1\u0bdf\u0001\u0000"+ + "\u0000\u0000\u0be2\u0be3\u0003\u025a\u012d\u0000\u0be3\u0bea\u0005k\u0000"+ + "\u0000\u0be4\u0beb\u0003\u02ac\u0156\u0000\u0be5\u0be6\u0005\u0111\u0000"+ + "\u0000\u0be6\u0be7\u0005\u0003\u0000\u0000\u0be7\u0be8\u0003\u02ac\u0156"+ + "\u0000\u0be8\u0be9\u0005\u0004\u0000\u0000\u0be9\u0beb\u0001\u0000\u0000"+ + "\u0000\u0bea\u0be4\u0001\u0000\u0000\u0000\u0bea\u0be5\u0001\u0000\u0000"+ + "\u0000\u0beb\u00e3\u0001\u0000\u0000\u0000\u0bec\u0bed\u0005i\u0000\u0000"+ + "\u0bed\u0bee\u0005\u0003\u0000\u0000\u0bee\u0bef\u0003\u048c\u0246\u0000"+ + "\u0bef\u0bf0\u0005\u0004\u0000\u0000\u0bf0\u0bf3\u0001\u0000\u0000\u0000"+ + "\u0bf1\u0bf3\u0001\u0000\u0000\u0000\u0bf2\u0bec\u0001\u0000\u0000\u0000"+ + "\u0bf2\u0bf1\u0001\u0000\u0000\u0000\u0bf3\u00e5\u0001\u0000\u0000\u0000"+ + "\u0bf4\u0bfe\u0003\u00e8t\u0000\u0bf5\u0bfe\u0003\u00eau\u0000\u0bf6\u0bf7"+ + "\u0003\u00e8t\u0000\u0bf7\u0bf8\u0003\u00eau\u0000\u0bf8\u0bfe\u0001\u0000"+ + "\u0000\u0000\u0bf9\u0bfa\u0003\u00eau\u0000\u0bfa\u0bfb\u0003\u00e8t\u0000"+ + "\u0bfb\u0bfe\u0001\u0000\u0000\u0000\u0bfc\u0bfe\u0001\u0000\u0000\u0000"+ + "\u0bfd\u0bf4\u0001\u0000\u0000\u0000\u0bfd\u0bf5\u0001\u0000\u0000\u0000"+ + "\u0bfd\u0bf6\u0001\u0000\u0000\u0000\u0bfd\u0bf9\u0001\u0000\u0000\u0000"+ + "\u0bfd\u0bfc\u0001\u0000\u0000\u0000\u0bfe\u00e7\u0001\u0000\u0000\u0000"+ + "\u0bff\u0c00\u0005R\u0000\u0000\u0c00\u0c01\u0005\u016c\u0000\u0000\u0c01"+ + "\u0c02\u0003\u00ecv\u0000\u0c02\u00e9\u0001\u0000\u0000\u0000\u0c03\u0c04"+ + "\u0005R\u0000\u0000\u0c04\u0c05\u0005\u00b8\u0000\u0000\u0c05\u0c06\u0003"+ + "\u00ecv\u0000\u0c06\u00eb\u0001\u0000\u0000\u0000\u0c07\u0c08\u0005\u0108"+ + "\u0000\u0000\u0c08\u0c0e\u0005\u0086\u0000\u0000\u0c09\u0c0e\u0005\u0136"+ + "\u0000\u0000\u0c0a\u0c0e\u0005\u0098\u0000\u0000\u0c0b\u0c0c\u0005\u0148"+ + "\u0000\u0000\u0c0c\u0c0e\u0007\u000f\u0000\u0000\u0c0d\u0c07\u0001\u0000"+ + "\u0000\u0000\u0c0d\u0c09\u0001\u0000\u0000\u0000\u0c0d\u0c0a\u0001\u0000"+ + "\u0000\u0000\u0c0d\u0c0b\u0001\u0000\u0000\u0000\u0c0e\u00ed\u0001\u0000"+ + "\u0000\u0000\u0c0f\u0c10\u0005\u00e7\u0000\u0000\u0c10\u0c11\u0005\u0003"+ + "\u0000\u0000\u0c11\u0c12\u0003\u0536\u029b\u0000\u0c12\u0c13\u0005\u0004"+ + "\u0000\u0000\u0c13\u0c16\u0001\u0000\u0000\u0000\u0c14\u0c16\u0001\u0000"+ + "\u0000\u0000\u0c15\u0c0f\u0001\u0000\u0000\u0000\u0c15\u0c14\u0001\u0000"+ + "\u0000\u0000\u0c16\u00ef\u0001\u0000\u0000\u0000\u0c17\u0c1a\u0003\u00f2"+ + "y\u0000\u0c18\u0c1a\u0001\u0000\u0000\u0000\u0c19\u0c17\u0001\u0000\u0000"+ + "\u0000\u0c19\u0c18\u0001\u0000\u0000\u0000\u0c1a\u00f1\u0001\u0000\u0000"+ + "\u0000\u0c1b\u0c1c\u0005\u0118\u0000\u0000\u0c1c\u0c1d\u0005\u0095\u0000"+ + "\u0000\u0c1d\u0c1e\u0003\u055c\u02ae\u0000\u0c1e\u0c1f\u0005\u0003\u0000"+ + "\u0000\u0c1f\u0c20\u0003\u00f4z\u0000\u0c20\u0c21\u0005\u0004\u0000\u0000"+ + "\u0c21\u00f3\u0001\u0000\u0000\u0000\u0c22\u0c27\u0003\u00f6{\u0000\u0c23"+ + "\u0c24\u0005\u0007\u0000\u0000\u0c24\u0c26\u0003\u00f6{\u0000\u0c25\u0c23"+ + "\u0001\u0000\u0000\u0000\u0c26\u0c29\u0001\u0000\u0000\u0000\u0c27\u0c25"+ + "\u0001\u0000\u0000\u0000\u0c27\u0c28\u0001\u0000\u0000\u0000\u0c28\u00f5"+ + "\u0001\u0000\u0000\u0000\u0c29\u0c27\u0001\u0000\u0000\u0000\u0c2a\u0c2b"+ + "\u0003\u055c\u02ae\u0000\u0c2b\u0c2c\u0003\u0260\u0130\u0000\u0c2c\u0c2d"+ + "\u0003\u0262\u0131\u0000\u0c2d\u0c39\u0001\u0000\u0000\u0000\u0c2e\u0c2f"+ + "\u0003\u04be\u025f\u0000\u0c2f\u0c30\u0003\u0260\u0130\u0000\u0c30\u0c31"+ + "\u0003\u0262\u0131\u0000\u0c31\u0c39\u0001\u0000\u0000\u0000\u0c32\u0c33"+ + "\u0005\u0003\u0000\u0000\u0c33\u0c34\u0003\u048c\u0246\u0000\u0c34\u0c35"+ + "\u0005\u0004\u0000\u0000\u0c35\u0c36\u0003\u0260\u0130\u0000\u0c36\u0c37"+ + "\u0003\u0262\u0131\u0000\u0c37\u0c39\u0001\u0000\u0000\u0000\u0c38\u0c2a"+ + "\u0001\u0000\u0000\u0000\u0c38\u0c2e\u0001\u0000\u0000\u0000\u0c38\u0c32"+ + "\u0001\u0000\u0000\u0000\u0c39\u00f7\u0001\u0000\u0000\u0000\u0c3a\u0c3b"+ + "\u0005f\u0000\u0000\u0c3b\u0c3e\u0003\u053c\u029e\u0000\u0c3c\u0c3e\u0001"+ + "\u0000\u0000\u0000\u0c3d\u0c3a\u0001\u0000\u0000\u0000\u0c3d\u0c3c\u0001"+ + "\u0000\u0000\u0000\u0c3e\u00f9\u0001\u0000\u0000\u0000\u0c3f\u0c40\u0005"+ + "k\u0000\u0000\u0c40\u0c45\u0003t:\u0000\u0c41\u0c42\u0005\u0176\u0000"+ + "\u0000\u0c42\u0c45\u0005\u0110\u0000\u0000\u0c43\u0c45\u0001\u0000\u0000"+ + "\u0000\u0c44\u0c3f\u0001\u0000\u0000\u0000\u0c44\u0c41\u0001\u0000\u0000"+ + "\u0000\u0c44\u0c43\u0001\u0000\u0000\u0000\u0c45\u00fb\u0001\u0000\u0000"+ + "\u0000\u0c46\u0c47\u0005R\u0000\u0000\u0c47\u0c4d\u0005\u00a3\u0000\u0000"+ + "\u0c48\u0c4e\u0005\u00c1\u0000\u0000\u0c49\u0c4a\u0005\u00b8\u0000\u0000"+ + "\u0c4a\u0c4e\u0005\u013b\u0000\u0000\u0c4b\u0c4c\u0005\u011f\u0000\u0000"+ + "\u0c4c\u0c4e\u0005\u013b\u0000\u0000\u0c4d\u0c48\u0001\u0000\u0000\u0000"+ + "\u0c4d\u0c49\u0001\u0000\u0000\u0000\u0c4d\u0c4b\u0001\u0000\u0000\u0000"+ + "\u0c4e\u0c51\u0001\u0000\u0000\u0000\u0c4f\u0c51\u0001\u0000\u0000\u0000"+ + "\u0c50\u0c46\u0001\u0000\u0000\u0000\u0c50\u0c4f\u0001\u0000\u0000\u0000"+ + "\u0c51\u00fd\u0001\u0000\u0000\u0000\u0c52\u0c53\u0005\u015a\u0000\u0000"+ + "\u0c53\u0c56\u0003\u053c\u029e\u0000\u0c54\u0c56\u0001\u0000\u0000\u0000"+ + "\u0c55\u0c52\u0001\u0000\u0000\u0000\u0c55\u0c54\u0001\u0000\u0000\u0000"+ + "\u0c56\u00ff\u0001\u0000\u0000\u0000\u0c57\u0c58\u0005f\u0000\u0000\u0c58"+ + "\u0c59\u0005\u00e4\u0000\u0000\u0c59\u0c5a\u0005\u015a\u0000\u0000\u0c5a"+ + "\u0c5d\u0003\u053c\u029e\u0000\u0c5b\u0c5d\u0001\u0000\u0000\u0000\u0c5c"+ + "\u0c57\u0001\u0000\u0000\u0000\u0c5c\u0c5b\u0001\u0000\u0000\u0000\u0c5d"+ + "\u0101\u0001\u0000\u0000\u0000\u0c5e\u0c5f\u0005f\u0000\u0000\u0c5f\u0c60"+ + "\u0005\u00e4\u0000\u0000\u0c60\u0c61\u0003\u053c\u029e\u0000\u0c61\u0103"+ + "\u0001\u0000\u0000\u0000\u0c62\u0c63\u00050\u0000\u0000\u0c63\u0c67\u0005"+ + "\u0151\u0000\u0000\u0c64\u0c65\u0005\u00de\u0000\u0000\u0c65\u0c66\u0005"+ + "O\u0000\u0000\u0c66\u0c68\u0005\u0187\u0000\u0000\u0c67\u0c64\u0001\u0000"+ + "\u0000\u0000\u0c67\u0c68\u0001\u0000\u0000\u0000\u0c68\u0c69\u0001\u0000"+ + "\u0000\u0000\u0c69\u0c6a\u0003\u020c\u0106\u0000\u0c6a\u0c6b\u0003\u0366"+ + "\u01b3\u0000\u0c6b\u0c6c\u0005R\u0000\u0000\u0c6c\u0c6d\u0003\u0500\u0280"+ + "\u0000\u0c6d\u0c6e\u0005B\u0000\u0000\u0c6e\u0c6f\u0003\u0422\u0211\u0000"+ + "\u0c6f\u0105\u0001\u0000\u0000\u0000\u0c70\u0c71\u0005\u008c\u0000\u0000"+ + "\u0c71\u0c74\u0005\u0151\u0000\u0000\u0c72\u0c73\u0005\u00de\u0000\u0000"+ + "\u0c73\u0c75\u0005\u0187\u0000\u0000\u0c74\u0c72\u0001\u0000\u0000\u0000"+ + "\u0c74\u0c75\u0001\u0000\u0000\u0000\u0c75\u0c76\u0001\u0000\u0000\u0000"+ + "\u0c76\u0c77\u0003\u020c\u0106\u0000\u0c77\u0c78\u0005\u0148\u0000\u0000"+ + "\u0c78\u0c79\u0005\u0151\u0000\u0000\u0c79\u0c7a\u0003\u0554\u02aa\u0000"+ + "\u0c7a\u0107\u0001\u0000\u0000\u0000\u0c7b\u0c7c\u00050\u0000\u0000\u0c7c"+ + "\u0c7d\u0003\u00aeW\u0000\u0c7d\u0c81\u0005^\u0000\u0000\u0c7e\u0c7f\u0005"+ + "\u00de\u0000\u0000\u0c7f\u0c80\u0005O\u0000\u0000\u0c80\u0c82\u0005\u0187"+ + "\u0000\u0000\u0c81\u0c7e\u0001\u0000\u0000\u0000\u0c81\u0c82\u0001\u0000"+ + "\u0000\u0000\u0c82\u0c83\u0001\u0000\u0000\u0000\u0c83\u0c84\u0003\u010a"+ + "\u0085\u0000\u0c84\u0c85\u0005&\u0000\u0000\u0c85\u0c86\u0003\u03c0\u01e0"+ + "\u0000\u0c86\u0c87\u0003\u010c\u0086\u0000\u0c87\u0109\u0001\u0000\u0000"+ + "\u0000\u0c88\u0c89\u0003\u0538\u029c\u0000\u0c89\u0c8a\u0003\u00d6k\u0000"+ + "\u0c8a\u0c8b\u0003\u00f8|\u0000\u0c8b\u0c8c\u0003\u00fa}\u0000\u0c8c\u0c8d"+ + "\u0003\u00fc~\u0000\u0c8d\u0c8e\u0003\u00fe\u007f\u0000\u0c8e\u010b\u0001"+ + "\u0000\u0000\u0000\u0c8f\u0c93\u0005k\u0000\u0000\u0c90\u0c94\u0005\u00b0"+ + "\u0000\u0000\u0c91\u0c92\u0005\u0108\u0000\u0000\u0c92\u0c94\u0005\u00b0"+ + "\u0000\u0000\u0c93\u0c90\u0001\u0000\u0000\u0000\u0c93\u0c91\u0001\u0000"+ + "\u0000\u0000\u0c94\u0c97\u0001\u0000\u0000\u0000\u0c95\u0c97\u0001\u0000"+ + "\u0000\u0000\u0c96\u0c8f\u0001\u0000\u0000\u0000\u0c96\u0c95\u0001\u0000"+ + "\u0000\u0000\u0c97\u010d\u0001\u0000\u0000\u0000\u0c98\u0c99\u00050\u0000"+ + "\u0000\u0c99\u0c9a\u0003\u0112\u0089\u0000\u0c9a\u0c9b\u0005\u00fd\u0000"+ + "\u0000\u0c9b\u0c9f\u0005\u0173\u0000\u0000\u0c9c\u0c9d\u0005\u00de\u0000"+ + "\u0000\u0c9d\u0c9e\u0005O\u0000\u0000\u0c9e\u0ca0\u0005\u0187\u0000\u0000"+ + "\u0c9f\u0c9c\u0001\u0000\u0000\u0000\u0c9f\u0ca0\u0001\u0000\u0000\u0000"+ + "\u0ca0\u0ca1\u0001\u0000\u0000\u0000\u0ca1\u0ca2\u0003\u0110\u0088\u0000"+ + "\u0ca2\u0ca3\u0005&\u0000\u0000\u0ca3\u0ca4\u0003\u03c0\u01e0\u0000\u0ca4"+ + "\u0ca5\u0003\u010c\u0086\u0000\u0ca5\u010f\u0001\u0000\u0000\u0000\u0ca6"+ + "\u0ca7\u0003\u0538\u029c\u0000\u0ca7\u0ca8\u0003\u00d6k\u0000\u0ca8\u0ca9"+ + "\u0003\u00f8|\u0000\u0ca9\u0caa\u0003v;\u0000\u0caa\u0cab\u0003\u00fe"+ + "\u007f\u0000\u0cab\u0111\u0001\u0000\u0000\u0000\u0cac\u0caf\u0005\u016a"+ + "\u0000\u0000\u0cad\u0caf\u0001\u0000\u0000\u0000\u0cae\u0cac\u0001\u0000"+ + "\u0000\u0000\u0cae\u0cad\u0001\u0000\u0000\u0000\u0caf\u0113\u0001\u0000"+ + "\u0000\u0000\u0cb0\u0cb1\u0005\u012c\u0000\u0000\u0cb1\u0cb2\u0005\u00fd"+ + "\u0000\u0000\u0cb2\u0cb3\u0005\u0173\u0000\u0000\u0cb3\u0cb4\u0003\u0250"+ + "\u0128\u0000\u0cb4\u0cb5\u0003\u0538\u029c\u0000\u0cb5\u0cb6\u0003\u010c"+ + "\u0086\u0000\u0cb6\u0115\u0001\u0000\u0000\u0000\u0cb7\u0cb8\u00050\u0000"+ + "\u0000\u0cb8\u0cb9\u0003\u00aeW\u0000\u0cb9\u0cbd\u0005\u0143\u0000\u0000"+ + "\u0cba\u0cbb\u0005\u00de\u0000\u0000\u0cbb\u0cbc\u0005O\u0000\u0000\u0cbc"+ + "\u0cbe\u0005\u0187\u0000\u0000\u0cbd\u0cba\u0001\u0000\u0000\u0000\u0cbd"+ + "\u0cbe\u0001\u0000\u0000\u0000\u0cbe\u0cbf\u0001\u0000\u0000\u0000\u0cbf"+ + "\u0cc0\u0003\u0538\u029c\u0000\u0cc0\u0cc1\u0003\u011a\u008d\u0000\u0cc1"+ + "\u0117\u0001\u0000\u0000\u0000\u0cc2\u0cc3\u0005\u008c\u0000\u0000\u0cc3"+ + "\u0cc6\u0005\u0143\u0000\u0000\u0cc4\u0cc5\u0005\u00de\u0000\u0000\u0cc5"+ + "\u0cc7\u0005\u0187\u0000\u0000\u0cc6\u0cc4\u0001\u0000\u0000\u0000\u0cc6"+ + "\u0cc7\u0001\u0000\u0000\u0000\u0cc7\u0cc8\u0001\u0000\u0000\u0000\u0cc8"+ + "\u0cc9\u0003\u0538\u029c\u0000\u0cc9\u0cca\u0003\u011e\u008f\u0000\u0cca"+ + "\u0119\u0001\u0000\u0000\u0000\u0ccb\u0cce\u0003\u011e\u008f\u0000\u0ccc"+ + "\u0cce\u0001\u0000\u0000\u0000\u0ccd\u0ccb\u0001\u0000\u0000\u0000\u0ccd"+ + "\u0ccc\u0001\u0000\u0000\u0000\u0cce\u011b\u0001\u0000\u0000\u0000\u0ccf"+ + "\u0cd0\u0005\u0003\u0000\u0000\u0cd0\u0cd1\u0003\u011e\u008f\u0000\u0cd1"+ + "\u0cd2\u0005\u0004\u0000\u0000\u0cd2\u0cd5\u0001\u0000\u0000\u0000\u0cd3"+ + "\u0cd5\u0001\u0000\u0000\u0000\u0cd4\u0ccf\u0001\u0000\u0000\u0000\u0cd4"+ + "\u0cd3\u0001\u0000\u0000\u0000\u0cd5\u011d\u0001\u0000\u0000\u0000\u0cd6"+ + "\u0cd8\u0003\u0120\u0090\u0000\u0cd7\u0cd6\u0001\u0000\u0000\u0000\u0cd8"+ + "\u0cd9\u0001\u0000\u0000\u0000\u0cd9\u0cd7\u0001\u0000\u0000\u0000\u0cd9"+ + "\u0cda\u0001\u0000\u0000\u0000\u0cda\u011f\u0001\u0000\u0000\u0000\u0cdb"+ + "\u0cdc\u0005&\u0000\u0000\u0cdc\u0cfa\u0003\u0464\u0232\u0000\u0cdd\u0cde"+ + "\u0005\u0096\u0000\u0000\u0cde\u0cfa\u0003\u0124\u0092\u0000\u0cdf\u0cfa"+ + "\u0005\u00af\u0000\u0000\u0ce0\u0ce1\u0005\u00e3\u0000\u0000\u0ce1\u0ce2"+ + "\u0003\u0122\u0091\u0000\u0ce2\u0ce3\u0003\u0124\u0092\u0000\u0ce3\u0cfa"+ + "\u0001\u0000\u0000\u0000\u0ce4\u0ce5\u0005\u00fe\u0000\u0000\u0ce5\u0cfa"+ + "\u0003\u0124\u0092\u0000\u0ce6\u0ce7\u0005\u0101\u0000\u0000\u0ce7\u0cfa"+ + "\u0003\u0124\u0092\u0000\u0ce8\u0ce9\u0005\u0108\u0000\u0000\u0ce9\u0cfa"+ + "\u0007\u0010\u0000\u0000\u0cea\u0ceb\u0005\u0114\u0000\u0000\u0ceb\u0cec"+ + "\u0005\u0095\u0000\u0000\u0cec\u0cfa\u0003\u020c\u0106\u0000\u0ced\u0cee"+ + "\u0005\u0143\u0000\u0000\u0cee\u0cef\u0005\u0105\u0000\u0000\u0cef\u0cfa"+ + "\u0003\u020c\u0106\u0000\u0cf0\u0cf1\u0005\u014f\u0000\u0000\u0cf1\u0cf2"+ + "\u0003\u0010\b\u0000\u0cf2\u0cf3\u0003\u0124\u0092\u0000\u0cf3\u0cfa\u0001"+ + "\u0000\u0000\u0000\u0cf4\u0cf5\u0005\u0135\u0000\u0000\u0cf5\u0cf7\u0003"+ + "\u0010\b\u0000\u0cf6\u0cf8\u0003\u0124\u0092\u0000\u0cf7\u0cf6\u0001\u0000"+ + "\u0000\u0000\u0cf7\u0cf8\u0001\u0000\u0000\u0000\u0cf8\u0cfa\u0001\u0000"+ + "\u0000\u0000\u0cf9\u0cdb\u0001\u0000\u0000\u0000\u0cf9\u0cdd\u0001\u0000"+ + "\u0000\u0000\u0cf9\u0cdf\u0001\u0000\u0000\u0000\u0cf9\u0ce0\u0001\u0000"+ + "\u0000\u0000\u0cf9\u0ce4\u0001\u0000\u0000\u0000\u0cf9\u0ce6\u0001\u0000"+ + "\u0000\u0000\u0cf9\u0ce8\u0001\u0000\u0000\u0000\u0cf9\u0cea\u0001\u0000"+ + "\u0000\u0000\u0cf9\u0ced\u0001\u0000\u0000\u0000\u0cf9\u0cf0\u0001\u0000"+ + "\u0000\u0000\u0cf9\u0cf4\u0001\u0000\u0000\u0000\u0cfa\u0121\u0001\u0000"+ + "\u0000\u0000\u0cfb\u0cfe\u0005\u0095\u0000\u0000\u0cfc\u0cfe\u0001\u0000"+ + "\u0000\u0000\u0cfd\u0cfb\u0001\u0000\u0000\u0000\u0cfd\u0cfc\u0001\u0000"+ + "\u0000\u0000\u0cfe\u0123\u0001\u0000\u0000\u0000\u0cff\u0d06\u0003\u054a"+ + "\u02a5\u0000\u0d00\u0d01\u0005\u000e\u0000\u0000\u0d01\u0d06\u0003\u054a"+ + "\u02a5\u0000\u0d02\u0d03\u0005\u000f\u0000\u0000\u0d03\u0d06\u0003\u054a"+ + "\u02a5\u0000\u0d04\u0d06\u0003\u0554\u02aa\u0000\u0d05\u0cff\u0001\u0000"+ + "\u0000\u0000\u0d05\u0d00\u0001\u0000\u0000\u0000\u0d05\u0d02\u0001\u0000"+ + "\u0000\u0000\u0d05\u0d04\u0001\u0000\u0000\u0000\u0d06\u0125\u0001\u0000"+ + "\u0000\u0000\u0d07\u0d0c\u0003\u0124\u0092\u0000\u0d08\u0d09\u0005\u0007"+ + "\u0000\u0000\u0d09\u0d0b\u0003\u0124\u0092\u0000\u0d0a\u0d08\u0001\u0000"+ + "\u0000\u0000\u0d0b\u0d0e\u0001\u0000\u0000\u0000\u0d0c\u0d0a\u0001\u0000"+ + "\u0000\u0000\u0d0c\u0d0d\u0001\u0000\u0000\u0000\u0d0d\u0127\u0001\u0000"+ + "\u0000\u0000\u0d0e\u0d0c\u0001\u0000\u0000\u0000\u0d0f\u0d10\u00050\u0000"+ + "\u0000\u0d10\u0d11\u0003\u026a\u0135\u0000\u0d11\u0d12\u0003\u012a\u0095"+ + "\u0000\u0d12\u0d13\u0003\u0134\u009a\u0000\u0d13\u0d14\u0005\u00f0\u0000"+ + "\u0000\u0d14\u0d1a\u0003\u053c\u029e\u0000\u0d15\u0d16\u0005\u00d9\u0000"+ + "\u0000\u0d16\u0d17\u0003\u012c\u0096\u0000\u0d17\u0d18\u0003\u012e\u0097"+ + "\u0000\u0d18\u0d19\u0003\u0132\u0099\u0000\u0d19\u0d1b\u0001\u0000\u0000"+ + "\u0000\u0d1a\u0d15\u0001\u0000\u0000\u0000\u0d1a\u0d1b\u0001\u0000\u0000"+ + "\u0000\u0d1b\u0129\u0001\u0000\u0000\u0000\u0d1c\u0d1f\u0005\u0162\u0000"+ + "\u0000\u0d1d\u0d1f\u0001\u0000\u0000\u0000\u0d1e\u0d1c\u0001\u0000\u0000"+ + "\u0000\u0d1e\u0d1d\u0001\u0000\u0000\u0000\u0d1f\u012b\u0001\u0000\u0000"+ + "\u0000\u0d20\u0d22\u0003\u053c\u029e\u0000\u0d21\u0d23\u0003\u020e\u0107"+ + "\u0000\u0d22\u0d21\u0001\u0000\u0000\u0000\u0d22\u0d23\u0001\u0000\u0000"+ + "\u0000\u0d23\u012d\u0001\u0000\u0000\u0000\u0d24\u0d25\u0005\u00e8\u0000"+ + "\u0000\u0d25\u0d28\u0003\u012c\u0096\u0000\u0d26\u0d28\u0001\u0000\u0000"+ + "\u0000\u0d27\u0d24\u0001\u0000\u0000\u0000\u0d27\u0d26\u0001\u0000\u0000"+ + "\u0000\u0d28\u012f\u0001\u0000\u0000\u0000\u0d29\u0d2a\u0005\u0170\u0000"+ + "\u0000\u0d2a\u0d2e\u0003\u012c\u0096\u0000\u0d2b\u0d2c\u0005\u0108\u0000"+ + "\u0000\u0d2c\u0d2e\u0005\u0170\u0000\u0000\u0d2d\u0d29\u0001\u0000\u0000"+ + "\u0000\u0d2d\u0d2b\u0001\u0000\u0000\u0000\u0d2e\u0131\u0001\u0000\u0000"+ + "\u0000\u0d2f\u0d32\u0003\u0130\u0098\u0000\u0d30\u0d32\u0001\u0000\u0000"+ + "\u0000\u0d31\u0d2f\u0001\u0000\u0000\u0000\u0d31\u0d30\u0001\u0000\u0000"+ + "\u0000\u0d32\u0133\u0001\u0000\u0000\u0000\u0d33\u0d36\u0005\u0122\u0000"+ + "\u0000\u0d34\u0d36\u0001\u0000\u0000\u0000\u0d35\u0d33\u0001\u0000\u0000"+ + "\u0000\u0d35\u0d34\u0001\u0000\u0000\u0000\u0d36\u0135\u0001\u0000\u0000"+ + "\u0000\u0d37\u0d38\u00050\u0000\u0000\u0d38\u0d39\u0005\u015a\u0000\u0000"+ + "\u0d39\u0d3a\u0003\u053c\u029e\u0000\u0d3a\u0d3b\u0003\u0138\u009c\u0000"+ + "\u0d3b\u0d3c\u0005\u00f8\u0000\u0000\u0d3c\u0d3d\u0003\u054e\u02a7\u0000"+ + "\u0d3d\u0d3e\u0003v;\u0000\u0d3e\u0137\u0001\u0000\u0000\u0000\u0d3f\u0d40"+ + "\u0005\u0115\u0000\u0000\u0d40\u0d43\u0003\u0558\u02ac\u0000\u0d41\u0d43"+ + "\u0001\u0000\u0000\u0000\u0d42\u0d3f\u0001\u0000\u0000\u0000\u0d42\u0d41"+ + "\u0001\u0000\u0000\u0000\u0d43\u0139\u0001\u0000\u0000\u0000\u0d44\u0d45"+ + "\u0005\u00c1\u0000\u0000\u0d45\u0d48\u0005\u015a\u0000\u0000\u0d46\u0d47"+ + "\u0005\u00de\u0000\u0000\u0d47\u0d49\u0005\u0187\u0000\u0000\u0d48\u0d46"+ + "\u0001\u0000\u0000\u0000\u0d48\u0d49\u0001\u0000\u0000\u0000\u0d49\u0d4a"+ + "\u0001\u0000\u0000\u0000\u0d4a\u0d4b\u0003\u053c\u029e\u0000\u0d4b\u013b"+ + "\u0001\u0000\u0000\u0000\u0d4c\u0d4d\u00050\u0000\u0000\u0d4d\u0d51\u0005"+ + "\u00ce\u0000\u0000\u0d4e\u0d4f\u0005\u00de\u0000\u0000\u0d4f\u0d50\u0005"+ + "O\u0000\u0000\u0d50\u0d52\u0005\u0187\u0000\u0000\u0d51\u0d4e\u0001\u0000"+ + "\u0000\u0000\u0d51\u0d52\u0001\u0000\u0000\u0000\u0d52\u0d53\u0001\u0000"+ + "\u0000\u0000\u0d53\u0d54\u0003\u053c\u029e\u0000\u0d54\u0d55\u0003\u0010"+ + "\b\u0000\u0d55\u0d56\u0003\u013e\u009f\u0000\u0d56\u013d\u0001\u0000\u0000"+ + "\u0000\u0d57\u0d59\u0003\u0140\u00a0\u0000\u0d58\u0d57\u0001\u0000\u0000"+ + "\u0000\u0d59\u0d5c\u0001\u0000\u0000\u0000\u0d5a\u0d58\u0001\u0000\u0000"+ + "\u0000\u0d5a\u0d5b\u0001\u0000\u0000\u0000\u0d5b\u013f\u0001\u0000\u0000"+ + "\u0000\u0d5c\u0d5a\u0001\u0000\u0000\u0000\u0d5d\u0d5e\u0005\u013e\u0000"+ + "\u0000\u0d5e\u0d65\u0003\u053c\u029e\u0000\u0d5f\u0d60\u0005\u0172\u0000"+ + "\u0000\u0d60\u0d65\u0003H$\u0000\u0d61\u0d62\u0005B\u0000\u0000\u0d62"+ + "\u0d65\u0003H$\u0000\u0d63\u0d65\u0005\u0098\u0000\u0000\u0d64\u0d5d\u0001"+ + "\u0000\u0000\u0000\u0d64\u0d5f\u0001\u0000\u0000\u0000\u0d64\u0d61\u0001"+ + "\u0000\u0000\u0000\u0d64\u0d63\u0001\u0000\u0000\u0000\u0d65\u0141\u0001"+ + "\u0000\u0000\u0000\u0d66\u0d67\u0005\u008c\u0000\u0000\u0d67\u0d68\u0005"+ + "\u00ce\u0000\u0000\u0d68\u0d69\u0003\u053c\u029e\u0000\u0d69\u0d6a\u0005"+ + "\u016c\u0000\u0000\u0d6a\u0d6b\u0003\u0144\u00a2\u0000\u0d6b\u0143\u0001"+ + "\u0000\u0000\u0000\u0d6c\u0d6e\u0003\u0146\u00a3\u0000\u0d6d\u0d6c\u0001"+ + "\u0000\u0000\u0000\u0d6e\u0d71\u0001\u0000\u0000\u0000\u0d6f\u0d6d\u0001"+ + "\u0000\u0000\u0000\u0d6f\u0d70\u0001\u0000\u0000\u0000\u0d70\u0145\u0001"+ + "\u0000\u0000\u0000\u0d71\u0d6f\u0001\u0000\u0000\u0000\u0d72\u0d73\u0005"+ + "`\u0000\u0000\u0d73\u0d74\u0003H$\u0000\u0d74\u0147\u0001\u0000\u0000"+ + "\u0000\u0d75\u0d76\u0005\u008c\u0000\u0000\u0d76\u0d77\u0005\u00ce\u0000"+ + "\u0000\u0d77\u0d78\u0003\u053c\u029e\u0000\u0d78\u0d79\u0003(\u0014\u0000"+ + "\u0d79\u0d7a\u0003\u0204\u0102\u0000\u0d7a\u0d7b\u0003\u053c\u029e\u0000"+ + "\u0d7b\u0dde\u0001\u0000\u0000\u0000\u0d7c\u0d7d\u0005\u008c\u0000\u0000"+ + "\u0d7d\u0d7e\u0005\u00ce\u0000\u0000\u0d7e\u0d7f\u0003\u053c\u029e\u0000"+ + "\u0d7f\u0d80\u0003(\u0014\u0000\u0d80\u0d81\u0003\u0202\u0101\u0000\u0d81"+ + "\u0d82\u0003\u020c\u0106\u0000\u0d82\u0dde\u0001\u0000\u0000\u0000\u0d83"+ + "\u0d84\u0005\u008c\u0000\u0000\u0d84\u0d85\u0005\u00ce\u0000\u0000\u0d85"+ + "\u0d86\u0003\u053c\u029e\u0000\u0d86\u0d87\u0003(\u0014\u0000\u0d87\u0d88"+ + "\u0005\u008a\u0000\u0000\u0d88\u0d89\u0003\u028a\u0145\u0000\u0d89\u0dde"+ + "\u0001\u0000\u0000\u0000\u0d8a\u0d8b\u0005\u008c\u0000\u0000\u0d8b\u0d8c"+ + "\u0005\u00ce\u0000\u0000\u0d8c\u0d8d\u0003\u053c\u029e\u0000\u0d8d\u0d8e"+ + "\u0003(\u0014\u0000\u0d8e\u0d8f\u0005+\u0000\u0000\u0d8f\u0d90\u0005\u0003"+ + "\u0000\u0000\u0d90\u0d91\u0003\u0460\u0230\u0000\u0d91\u0d92\u0005&\u0000"+ + "\u0000\u0d92\u0d93\u0003\u0460\u0230\u0000\u0d93\u0d94\u0005\u0004\u0000"+ + "\u0000\u0d94\u0dde\u0001\u0000\u0000\u0000\u0d95\u0d96\u0005\u008c\u0000"+ + "\u0000\u0d96\u0d97\u0005\u00ce\u0000\u0000\u0d97\u0d98\u0003\u053c\u029e"+ + "\u0000\u0d98\u0d99\u0003(\u0014\u0000\u0d99\u0d9a\u0005\u00bf\u0000\u0000"+ + "\u0d9a\u0d9b\u0003\u0460\u0230\u0000\u0d9b\u0dde\u0001\u0000\u0000\u0000"+ + "\u0d9c\u0d9d\u0005\u008c\u0000\u0000\u0d9d\u0d9e\u0005\u00ce\u0000\u0000"+ + "\u0d9e\u0d9f\u0003\u053c\u029e\u0000\u0d9f\u0da0\u0003(\u0014\u0000\u0da0"+ + "\u0da1\u0005\u00d5\u0000\u0000\u0da1\u0da2\u0003\u0272\u0139\u0000\u0da2"+ + "\u0dde\u0001\u0000\u0000\u0000\u0da3\u0da4\u0005\u008c\u0000\u0000\u0da4"+ + "\u0da5\u0005\u00ce\u0000\u0000\u0da5\u0da6\u0003\u053c\u029e\u0000\u0da6"+ + "\u0da7\u0003(\u0014\u0000\u0da7\u0da8\u0005\u0111\u0000\u0000\u0da8\u0da9"+ + "\u0003\u02b0\u0158\u0000\u0da9\u0dde\u0001\u0000\u0000\u0000\u0daa\u0dab"+ + "\u0005\u008c\u0000\u0000\u0dab\u0dac\u0005\u00ce\u0000\u0000\u0dac\u0dad"+ + "\u0003\u053c\u029e\u0000\u0dad\u0dae\u0003(\u0014\u0000\u0dae\u0daf\u0005"+ + "\u0111\u0000\u0000\u0daf\u0db0\u0005\u009e\u0000\u0000\u0db0\u0db1\u0003"+ + "\u020c\u0106\u0000\u0db1\u0db2\u0005f\u0000\u0000\u0db2\u0db3\u0003\u053c"+ + "\u029e\u0000\u0db3\u0dde\u0001\u0000\u0000\u0000\u0db4\u0db5\u0005\u008c"+ + "\u0000\u0000\u0db5\u0db6\u0005\u00ce\u0000\u0000\u0db6\u0db7\u0003\u053c"+ + "\u029e\u0000\u0db7\u0db8\u0003(\u0014\u0000\u0db8\u0db9\u0005\u0111\u0000"+ + "\u0000\u0db9\u0dba\u0005\u00d0\u0000\u0000\u0dba\u0dbb\u0003\u020c\u0106"+ + "\u0000\u0dbb\u0dbc\u0005f\u0000\u0000\u0dbc\u0dbd\u0003\u053c\u029e\u0000"+ + "\u0dbd\u0dde\u0001\u0000\u0000\u0000\u0dbe\u0dbf\u0005\u008c\u0000\u0000"+ + "\u0dbf\u0dc0\u0005\u00ce\u0000\u0000\u0dc0\u0dc1\u0003\u053c\u029e\u0000"+ + "\u0dc1\u0dc2\u0003(\u0014\u0000\u0dc2\u0dc3\u0005\u0123\u0000\u0000\u0dc3"+ + "\u0dc4\u0003\u0272\u0139\u0000\u0dc4\u0dde\u0001\u0000\u0000\u0000\u0dc5"+ + "\u0dc6\u0005\u008c\u0000\u0000\u0dc6\u0dc7\u0005\u00ce\u0000\u0000\u0dc7"+ + "\u0dc8\u0003\u053c\u029e\u0000\u0dc8\u0dc9\u0003(\u0014\u0000\u0dc9\u0dca"+ + "\u0005\u01bc\u0000\u0000\u0dca\u0dcb\u0003\u0272\u0139\u0000\u0dcb\u0dde"+ + "\u0001\u0000\u0000\u0000\u0dcc\u0dcd\u0005\u008c\u0000\u0000\u0dcd\u0dce"+ + "\u0005\u00ce\u0000\u0000\u0dce\u0dcf\u0003\u053c\u029e\u0000\u0dcf\u0dd0"+ + "\u0003(\u0014\u0000\u0dd0\u0dd1\u0005\u01bd\u0000\u0000\u0dd1\u0dd2\u0005"+ + "@\u0000\u0000\u0dd2\u0dd3\u0003\u0460\u0230\u0000\u0dd3\u0dd4\u0005\u00f0"+ + "\u0000\u0000\u0dd4\u0dd5\u0003\u053c\u029e\u0000\u0dd5\u0dde\u0001\u0000"+ + "\u0000\u0000\u0dd6\u0dd7\u0005\u008c\u0000\u0000\u0dd7\u0dd8\u0005\u00ce"+ + "\u0000\u0000\u0dd8\u0dd9\u0003\u053c\u029e\u0000\u0dd9\u0dda\u0003(\u0014"+ + "\u0000\u0dda\u0ddb\u0005\u0163\u0000\u0000\u0ddb\u0ddc\u0003\u0460\u0230"+ + "\u0000\u0ddc\u0dde\u0001\u0000\u0000\u0000\u0ddd\u0d75\u0001\u0000\u0000"+ + "\u0000\u0ddd\u0d7c\u0001\u0000\u0000\u0000\u0ddd\u0d83\u0001\u0000\u0000"+ + "\u0000\u0ddd\u0d8a\u0001\u0000\u0000\u0000\u0ddd\u0d95\u0001\u0000\u0000"+ + "\u0000\u0ddd\u0d9c\u0001\u0000\u0000\u0000\u0ddd\u0da3\u0001\u0000\u0000"+ + "\u0000\u0ddd\u0daa\u0001\u0000\u0000\u0000\u0ddd\u0db4\u0001\u0000\u0000"+ + "\u0000\u0ddd\u0dbe\u0001\u0000\u0000\u0000\u0ddd\u0dc5\u0001\u0000\u0000"+ + "\u0000\u0ddd\u0dcc\u0001\u0000\u0000\u0000\u0ddd\u0dd6\u0001\u0000\u0000"+ + "\u0000\u0dde\u0149\u0001\u0000\u0000\u0000\u0ddf\u0de0\u00050\u0000\u0000"+ + "\u0de0\u0de1\u0005A\u0000\u0000\u0de1\u0de2\u0005\u00b0\u0000\u0000\u0de2"+ + "\u0de3\u0005\u0178\u0000\u0000\u0de3\u0de4\u0003\u053c\u029e\u0000\u0de4"+ + "\u0de5\u0003\u0150\u00a8\u0000\u0de5\u0de6\u0003\u0154\u00aa\u0000\u0de6"+ + "\u014b\u0001\u0000\u0000\u0000\u0de7\u0de8\u0005\u00d9\u0000\u0000\u0de8"+ + "\u0df0\u0003\u012c\u0096\u0000\u0de9\u0dea\u0005\u0108\u0000\u0000\u0dea"+ + "\u0df0\u0005\u00d9\u0000\u0000\u0deb\u0dec\u0005\u0170\u0000\u0000\u0dec"+ + "\u0df0\u0003\u012c\u0096\u0000\u0ded\u0dee\u0005\u0108\u0000\u0000\u0dee"+ + "\u0df0\u0005\u0170\u0000\u0000\u0def\u0de7\u0001\u0000\u0000\u0000\u0def"+ + "\u0de9\u0001\u0000\u0000\u0000\u0def\u0deb\u0001\u0000\u0000\u0000\u0def"+ + "\u0ded\u0001\u0000\u0000\u0000\u0df0\u014d\u0001\u0000\u0000\u0000\u0df1"+ + "\u0df3\u0003\u014c\u00a6\u0000\u0df2\u0df1\u0001\u0000\u0000\u0000\u0df3"+ + "\u0df4\u0001\u0000\u0000\u0000\u0df4\u0df2\u0001\u0000\u0000\u0000\u0df4"+ + "\u0df5\u0001\u0000\u0000\u0000\u0df5\u014f\u0001\u0000\u0000\u0000\u0df6"+ + "\u0df9\u0003\u014e\u00a7\u0000\u0df7\u0df9\u0001\u0000\u0000\u0000\u0df8"+ + "\u0df6\u0001\u0000\u0000\u0000\u0df8\u0df7\u0001\u0000\u0000\u0000\u0df9"+ + "\u0151\u0001\u0000\u0000\u0000\u0dfa\u0dfb\u0005\u008c\u0000\u0000\u0dfb"+ + "\u0dfc\u0005A\u0000\u0000\u0dfc\u0dfd\u0005\u00b0\u0000\u0000\u0dfd\u0dfe"+ + "\u0005\u0178\u0000\u0000\u0dfe\u0dff\u0003\u053c\u029e\u0000\u0dff\u0e00"+ + "\u0003\u0150\u00a8\u0000\u0e00\u0e01\u0003\u0158\u00ac\u0000\u0e01\u0e0a"+ + "\u0001\u0000\u0000\u0000\u0e02\u0e03\u0005\u008c\u0000\u0000\u0e03\u0e04"+ + "\u0005A\u0000\u0000\u0e04\u0e05\u0005\u00b0\u0000\u0000\u0e05\u0e06\u0005"+ + "\u0178\u0000\u0000\u0e06\u0e07\u0003\u053c\u029e\u0000\u0e07\u0e08\u0003"+ + "\u014e\u00a7\u0000\u0e08\u0e0a\u0001\u0000\u0000\u0000\u0e09\u0dfa\u0001"+ + "\u0000\u0000\u0000\u0e09\u0e02\u0001\u0000\u0000\u0000\u0e0a\u0153\u0001"+ + "\u0000\u0000\u0000\u0e0b\u0e0c\u0005\u0113\u0000\u0000\u0e0c\u0e0d\u0005"+ + "\u0003\u0000\u0000\u0e0d\u0e0e\u0003\u0156\u00ab\u0000\u0e0e\u0e0f\u0005"+ + "\u0004\u0000\u0000\u0e0f\u0e12\u0001\u0000\u0000\u0000\u0e10\u0e12\u0001"+ + "\u0000\u0000\u0000\u0e11\u0e0b\u0001\u0000\u0000\u0000\u0e11\u0e10\u0001"+ + "\u0000\u0000\u0000\u0e12\u0155\u0001\u0000\u0000\u0000\u0e13\u0e18\u0003"+ + "\u015e\u00af\u0000\u0e14\u0e15\u0005\u0007\u0000\u0000\u0e15\u0e17\u0003"+ + "\u015e\u00af\u0000\u0e16\u0e14\u0001\u0000\u0000\u0000\u0e17\u0e1a\u0001"+ + "\u0000\u0000\u0000\u0e18\u0e16\u0001\u0000\u0000\u0000\u0e18\u0e19\u0001"+ + "\u0000\u0000\u0000\u0e19\u0157\u0001\u0000\u0000\u0000\u0e1a\u0e18\u0001"+ + "\u0000\u0000\u0000\u0e1b\u0e1c\u0005\u0113\u0000\u0000\u0e1c\u0e1d\u0005"+ + "\u0003\u0000\u0000\u0e1d\u0e1e\u0003\u015a\u00ad\u0000\u0e1e\u0e1f\u0005"+ + "\u0004\u0000\u0000\u0e1f\u0159\u0001\u0000\u0000\u0000\u0e20\u0e25\u0003"+ + "\u015c\u00ae\u0000\u0e21\u0e22\u0005\u0007\u0000\u0000\u0e22\u0e24\u0003"+ + "\u015c\u00ae\u0000\u0e23\u0e21\u0001\u0000\u0000\u0000\u0e24\u0e27\u0001"+ + "\u0000\u0000\u0000\u0e25\u0e23\u0001\u0000\u0000\u0000\u0e25\u0e26\u0001"+ + "\u0000\u0000\u0000\u0e26\u015b\u0001\u0000\u0000\u0000\u0e27\u0e25\u0001"+ + "\u0000\u0000\u0000\u0e28\u0e30\u0003\u015e\u00af\u0000\u0e29\u0e2a\u0005"+ + "\u0148\u0000\u0000\u0e2a\u0e30\u0003\u015e\u00af\u0000\u0e2b\u0e2c\u0005"+ + "\u0087\u0000\u0000\u0e2c\u0e30\u0003\u015e\u00af\u0000\u0e2d\u0e2e\u0005"+ + "\u00c1\u0000\u0000\u0e2e\u0e30\u0003\u0160\u00b0\u0000\u0e2f\u0e28\u0001"+ + "\u0000\u0000\u0000\u0e2f\u0e29\u0001\u0000\u0000\u0000\u0e2f\u0e2b\u0001"+ + "\u0000\u0000\u0000\u0e2f\u0e2d\u0001\u0000\u0000\u0000\u0e30\u015d\u0001"+ + "\u0000\u0000\u0000\u0e31\u0e32\u0003\u0160\u00b0\u0000\u0e32\u0e33\u0003"+ + "\u0162\u00b1\u0000\u0e33\u015f\u0001\u0000\u0000\u0000\u0e34\u0e35\u0003"+ + "\u0564\u02b2\u0000\u0e35\u0161\u0001\u0000\u0000\u0000\u0e36\u0e37\u0003"+ + "\u054e\u02a7\u0000\u0e37\u0163\u0001\u0000\u0000\u0000\u0e38\u0e39\u0005"+ + "0\u0000\u0000\u0e39\u0e3a\u0005\u0146\u0000\u0000\u0e3a\u0e3b\u0003\u053c"+ + "\u029e\u0000\u0e3b\u0e3c\u0003\u0166\u00b3\u0000\u0e3c\u0e3d\u0003\u016a"+ + "\u00b5\u0000\u0e3d\u0e3e\u0005A\u0000\u0000\u0e3e\u0e3f\u0005\u00b0\u0000"+ + "\u0000\u0e3f\u0e40\u0005\u0178\u0000\u0000\u0e40\u0e41\u0003\u053c\u029e"+ + "\u0000\u0e41\u0e42\u0003\u0154\u00aa\u0000\u0e42\u0e52\u0001\u0000\u0000"+ + "\u0000\u0e43\u0e44\u00050\u0000\u0000\u0e44\u0e45\u0005\u0146\u0000\u0000"+ + "\u0e45\u0e46\u0005\u00de\u0000\u0000\u0e46\u0e47\u0005O\u0000\u0000\u0e47"+ + "\u0e48\u0005\u0187\u0000\u0000\u0e48\u0e49\u0003\u053c\u029e\u0000\u0e49"+ + "\u0e4a\u0003\u0166\u00b3\u0000\u0e4a\u0e4b\u0003\u016a\u00b5\u0000\u0e4b"+ + "\u0e4c\u0005A\u0000\u0000\u0e4c\u0e4d\u0005\u00b0\u0000\u0000\u0e4d\u0e4e"+ + "\u0005\u0178\u0000\u0000\u0e4e\u0e4f\u0003\u053c\u029e\u0000\u0e4f\u0e50"+ + "\u0003\u0154\u00aa\u0000\u0e50\u0e52\u0001\u0000\u0000\u0000\u0e51\u0e38"+ + "\u0001\u0000\u0000\u0000\u0e51\u0e43\u0001\u0000\u0000\u0000\u0e52\u0165"+ + "\u0001\u0000\u0000\u0000\u0e53\u0e54\u0005\u0163\u0000\u0000\u0e54\u0e57"+ + "\u0003\u054e\u02a7\u0000\u0e55\u0e57\u0001\u0000\u0000\u0000\u0e56\u0e53"+ + "\u0001\u0000\u0000\u0000\u0e56\u0e55\u0001\u0000\u0000\u0000\u0e57\u0167"+ + "\u0001\u0000\u0000\u0000\u0e58\u0e5b\u0005\u0172\u0000\u0000\u0e59\u0e5c"+ + "\u0003\u054e\u02a7\u0000\u0e5a\u0e5c\u0005P\u0000\u0000\u0e5b\u0e59\u0001"+ + "\u0000\u0000\u0000\u0e5b\u0e5a\u0001\u0000\u0000\u0000\u0e5c\u0169\u0001"+ + "\u0000\u0000\u0000\u0e5d\u0e60\u0003\u0168\u00b4\u0000\u0e5e\u0e60\u0001"+ + "\u0000\u0000\u0000\u0e5f\u0e5d\u0001\u0000\u0000\u0000\u0e5f\u0e5e\u0001"+ + "\u0000\u0000\u0000\u0e60\u016b\u0001\u0000\u0000\u0000\u0e61\u0e62\u0005"; private static final String _serializedATNSegment2 = - "\u0000\u0000\u0000\u1173\u0199\u0001\u0000\u0000\u0000\u1174\u1172\u0001"+ - "\u0000\u0000\u0000\u1175\u1176\u0003\u0220\u0110\u0000\u1176\u1177\u0005"+ - "\u001b\u0000\u0000\u1177\u1178\u0003\u019e\u00cf\u0000\u1178\u019b\u0001"+ - "\u0000\u0000\u0000\u1179\u117a\u0005\u0287\u0000\u0000\u117a\u117b\u0003"+ - "\u0198\u00cc\u0000\u117b\u019d\u0001\u0000\u0000\u0000\u117c\u117e\u0005"+ - "\u0300\u0000\u0000\u117d\u117f\u0003\u0220\u0110\u0000\u117e\u117d\u0001"+ - "\u0000\u0000\u0000\u117e\u117f\u0001\u0000\u0000\u0000\u117f\u1181\u0001"+ - "\u0000\u0000\u0000\u1180\u1182\u0003\u01a0\u00d0\u0000\u1181\u1180\u0001"+ - "\u0000\u0000\u0000\u1181\u1182\u0001\u0000\u0000\u0000\u1182\u1184\u0001"+ - "\u0000\u0000\u0000\u1183\u1185\u0003\u01a6\u00d3\u0000\u1184\u1183\u0001"+ - "\u0000\u0000\u0000\u1184\u1185\u0001\u0000\u0000\u0000\u1185\u1187\u0001"+ - "\u0000\u0000\u0000\u1186\u1188\u0003\u0196\u00cb\u0000\u1187\u1186\u0001"+ - "\u0000\u0000\u0000\u1187\u1188\u0001\u0000\u0000\u0000\u1188\u1189\u0001"+ - "\u0000\u0000\u0000\u1189\u118a\u0005\u0301\u0000\u0000\u118a\u019f\u0001"+ - "\u0000\u0000\u0000\u118b\u118c\u0005\u019f\u0000\u0000\u118c\u118d\u0005"+ - "6\u0000\u0000\u118d\u1192\u0003\u01b8\u00dc\u0000\u118e\u118f\u0005\u02fa"+ - "\u0000\u0000\u118f\u1191\u0003\u01b8\u00dc\u0000\u1190\u118e\u0001\u0000"+ - "\u0000\u0000\u1191\u1194\u0001\u0000\u0000\u0000\u1192\u1190\u0001\u0000"+ - "\u0000\u0000\u1192\u1193\u0001\u0000\u0000\u0000\u1193\u01a1\u0001\u0000"+ - "\u0000\u0000\u1194\u1192\u0001\u0000\u0000\u0000\u1195\u1198\u0005\u018f"+ - "\u0000\u0000\u1196\u1199\u0003\u019e\u00cf\u0000\u1197\u1199\u0003\u0220"+ - "\u0110\u0000\u1198\u1196\u0001\u0000\u0000\u0000\u1198\u1197\u0001\u0000"+ - "\u0000\u0000\u1199\u01a3\u0001\u0000\u0000\u0000\u119a\u119c\u0007\u001d"+ - "\u0000\u0000\u119b\u119d\u0007\u001e\u0000\u0000\u119c\u119b\u0001\u0000"+ - "\u0000\u0000\u119c\u119d\u0001\u0000\u0000\u0000\u119d\u11a1\u0001\u0000"+ - "\u0000\u0000\u119e\u11a0\u0005\u0300\u0000\u0000\u119f\u119e\u0001\u0000"+ - "\u0000\u0000\u11a0\u11a3\u0001\u0000\u0000\u0000\u11a1\u119f\u0001\u0000"+ - "\u0000\u0000\u11a1\u11a2\u0001\u0000\u0000\u0000\u11a2\u11a6\u0001\u0000"+ - "\u0000\u0000\u11a3\u11a1\u0001\u0000\u0000\u0000\u11a4\u11a7\u0003\u0158"+ - "\u00ac\u0000\u11a5\u11a7\u0003\u017c\u00be\u0000\u11a6\u11a4\u0001\u0000"+ - "\u0000\u0000\u11a6\u11a5\u0001\u0000\u0000\u0000\u11a7\u11ab\u0001\u0000"+ - "\u0000\u0000\u11a8\u11aa\u0005\u0301\u0000\u0000\u11a9\u11a8\u0001\u0000"+ - "\u0000\u0000\u11aa\u11ad\u0001\u0000\u0000\u0000\u11ab\u11a9\u0001\u0000"+ - "\u0000\u0000\u11ab\u11ac\u0001\u0000\u0000\u0000\u11ac\u11af\u0001\u0000"+ - "\u0000\u0000\u11ad\u11ab\u0001\u0000\u0000\u0000\u11ae\u11b0\u0003\u01a4"+ - "\u00d2\u0000\u11af\u11ae\u0001\u0000\u0000\u0000\u11af\u11b0\u0001\u0000"+ - "\u0000\u0000\u11b0\u01a5\u0001\u0000\u0000\u0000\u11b1\u11b2\u0005\u0188"+ - "\u0000\u0000\u11b2\u11b3\u00056\u0000\u0000\u11b3\u11b8\u0003\u01a8\u00d4"+ - "\u0000\u11b4\u11b5\u0005\u02fa\u0000\u0000\u11b5\u11b7\u0003\u01a8\u00d4"+ - "\u0000\u11b6\u11b4\u0001\u0000\u0000\u0000\u11b7\u11ba\u0001\u0000\u0000"+ - "\u0000\u11b8\u11b6\u0001\u0000\u0000\u0000\u11b8\u11b9\u0001\u0000\u0000"+ - "\u0000\u11b9\u01a7\u0001\u0000\u0000\u0000\u11ba\u11b8\u0001\u0000\u0000"+ - "\u0000\u11bb\u11be\u0003\u01b8\u00dc\u0000\u11bc\u11be\u0005\u030b\u0000"+ - "\u0000\u11bd\u11bb\u0001\u0000\u0000\u0000\u11bd\u11bc\u0001\u0000\u0000"+ - "\u0000\u11be\u11c3\u0001\u0000\u0000\u0000\u11bf\u11c4\u0005\u001c\u0000"+ - "\u0000\u11c0\u11c4\u0005\u00ab\u0000\u0000\u11c1\u11c2\u0005\u0273\u0000"+ - "\u0000\u11c2\u11c4\u0003\u01b8\u00dc\u0000\u11c3\u11bf\u0001\u0000\u0000"+ - "\u0000\u11c3\u11c0\u0001\u0000\u0000\u0000\u11c3\u11c1\u0001\u0000\u0000"+ - "\u0000\u11c3\u11c4\u0001\u0000\u0000\u0000\u11c4\u11d0\u0001\u0000\u0000"+ - "\u0000\u11c5\u11c6\u0005\u0175\u0000\u0000\u11c6\u11c7\u0007\u001f\u0000"+ - "\u0000\u11c7\u11cd\u0001\u0000\u0000\u0000\u11c8\u11c9\u0005\u02fa\u0000"+ - "\u0000\u11c9\u11ca\u0005\u0175\u0000\u0000\u11ca\u11cc\u0007\u001f\u0000"+ - "\u0000\u11cb\u11c8\u0001\u0000\u0000\u0000\u11cc\u11cf\u0001\u0000\u0000"+ - "\u0000\u11cd\u11cb\u0001\u0000\u0000\u0000\u11cd\u11ce\u0001\u0000\u0000"+ - "\u0000\u11ce\u11d1\u0001\u0000\u0000\u0000\u11cf\u11cd\u0001\u0000\u0000"+ - "\u0000\u11d0\u11c5\u0001\u0000\u0000\u0000\u11d0\u11d1\u0001\u0000\u0000"+ - "\u0000\u11d1\u01a9\u0001\u0000\u0000\u0000\u11d2\u11d6\u0005\u0136\u0000"+ - "\u0000\u11d3\u11d7\u0003\u01bc\u00de\u0000\u11d4\u11d7\u0005\u0010\u0000"+ - "\u0000\u11d5\u11d7\u0003\u01ec\u00f6\u0000\u11d6\u11d3\u0001\u0000\u0000"+ - "\u0000\u11d6\u11d4\u0001\u0000\u0000\u0000\u11d6\u11d5\u0001\u0000\u0000"+ - "\u0000\u11d7\u01ab\u0001\u0000\u0000\u0000\u11d8\u11d9\u0005\u017d\u0000"+ - "\u0000\u11d9\u11db\u0003\u01bc\u00de\u0000\u11da\u11dc\u0007 \u0000\u0000"+ - "\u11db\u11da\u0001\u0000\u0000\u0000\u11db\u11dc\u0001\u0000\u0000\u0000"+ - "\u11dc\u01ad\u0001\u0000\u0000\u0000\u11dd\u11de\u0005\u00db\u0000\u0000"+ - "\u11de\u11e0\u0007!\u0000\u0000\u11df\u11e1\u0003\u01bc\u00de\u0000\u11e0"+ - "\u11df\u0001\u0000\u0000\u0000\u11e0\u11e1\u0001\u0000\u0000\u0000\u11e1"+ - "\u11e2\u0001\u0000\u0000\u0000\u11e2\u11e3\u0007 \u0000\u0000\u11e3\u11e4"+ - "\u0005\u0181\u0000\u0000\u11e4\u01af\u0001\u0000\u0000\u0000\u11e5\u11ed"+ - "\u0005\u00e3\u0000\u0000\u11e6\u11ee\u0005\u026b\u0000\u0000\u11e7\u11e8"+ - "\u0005\u0167\u0000\u0000\u11e8\u11e9\u0005\u0126\u0000\u0000\u11e9\u11ee"+ - "\u0005\u026b\u0000\u0000\u11ea\u11ee\u0005\u020a\u0000\u0000\u11eb\u11ec"+ - "\u0005\u0126\u0000\u0000\u11ec\u11ee\u0005\u020a\u0000\u0000\u11ed\u11e6"+ - "\u0001\u0000\u0000\u0000\u11ed\u11e7\u0001\u0000\u0000\u0000\u11ed\u11ea"+ - "\u0001\u0000\u0000\u0000\u11ed\u11eb\u0001\u0000\u0000\u0000\u11ee\u11f8"+ - "\u0001\u0000\u0000\u0000\u11ef\u11f0\u0005\u017b\u0000\u0000\u11f0\u11f5"+ - "\u0003\u01e2\u00f1\u0000\u11f1\u11f2\u0005\u02fa\u0000\u0000\u11f2\u11f4"+ - "\u0003\u01e2\u00f1\u0000\u11f3\u11f1\u0001\u0000\u0000\u0000\u11f4\u11f7"+ - "\u0001\u0000\u0000\u0000\u11f5\u11f3\u0001\u0000\u0000\u0000\u11f5\u11f6"+ - "\u0001\u0000\u0000\u0000\u11f6\u11f9\u0001\u0000\u0000\u0000\u11f7\u11f5"+ - "\u0001\u0000\u0000\u0000\u11f8\u11ef\u0001\u0000\u0000\u0000\u11f8\u11f9"+ - "\u0001\u0000\u0000\u0000\u11f9\u11ff\u0001\u0000\u0000\u0000\u11fa\u11fe"+ - "\u0005\u0171\u0000\u0000\u11fb\u11fc\u0005\u020f\u0000\u0000\u11fc\u11fe"+ - "\u0005\u0140\u0000\u0000\u11fd\u11fa\u0001\u0000\u0000\u0000\u11fd\u11fb"+ - "\u0001\u0000\u0000\u0000\u11fe\u1201\u0001\u0000\u0000\u0000\u11ff\u11fd"+ - "\u0001\u0000\u0000\u0000\u11ff\u1200\u0001\u0000\u0000\u0000\u1200\u01b1"+ - "\u0001\u0000\u0000\u0000\u1201\u11ff\u0001\u0000\u0000\u0000\u1202\u1207"+ - "\u0003\u01b4\u00da\u0000\u1203\u1204\u0005\u02fa\u0000\u0000\u1204\u1206"+ - "\u0003\u01b4\u00da\u0000\u1205\u1203\u0001\u0000\u0000\u0000\u1206\u1209"+ - "\u0001\u0000\u0000\u0000\u1207\u1205\u0001\u0000\u0000\u0000\u1207\u1208"+ - "\u0001\u0000\u0000\u0000\u1208\u01b3\u0001\u0000\u0000\u0000\u1209\u1207"+ - "\u0001\u0000\u0000\u0000\u120a\u1214\u0003\u01b8\u00dc\u0000\u120b\u120c"+ - "\u0005\u0300\u0000\u0000\u120c\u120d\u0003\u01da\u00ed\u0000\u120d\u120e"+ - "\u0005\u0301\u0000\u0000\u120e\u1211\u0005\u0319\u0000\u0000\u120f\u1212"+ - "\u0003\u01b8\u00dc\u0000\u1210\u1212\u0003\u01c4\u00e2\u0000\u1211\u120f"+ - "\u0001\u0000\u0000\u0000\u1211\u1210\u0001\u0000\u0000\u0000\u1212\u1214"+ - "\u0001\u0000\u0000\u0000\u1213\u120a\u0001\u0000\u0000\u0000\u1213\u120b"+ - "\u0001\u0000\u0000\u0000\u1214\u01b5\u0001\u0000\u0000\u0000\u1215\u1216"+ - "\u0005\u01e1\u0000\u0000\u1216\u1217\u0003\u018c\u00c6\u0000\u1217\u01b7"+ - "\u0001\u0000\u0000\u0000\u1218\u1219\u0006\u00dc\uffff\uffff\u0000\u1219"+ - "\u1267\u0005\u0172\u0000\u0000\u121a\u1267\u0005\u0086\u0000\u0000\u121b"+ - "\u1267\u0005\u0089\u0000\u0000\u121c\u1267\u0005\u008a\u0000\u0000\u121d"+ - "\u1267\u0005\u008b\u0000\u0000\u121e\u1267\u0005\u008d\u0000\u0000\u121f"+ - "\u1267\u0005\u009b\u0000\u0000\u1220\u1267\u0005\u0307\u0000\u0000\u1221"+ - "\u1267\u0005\u0308\u0000\u0000\u1222\u1267\u0005\u0306\u0000\u0000\u1223"+ - "\u1267\u0005\u030a\u0000\u0000\u1224\u1267\u0005\u0304\u0000\u0000\u1225"+ - "\u1267\u0005\u0305\u0000\u0000\u1226\u1228\u0005\u02fe\u0000\u0000\u1227"+ - "\u1229\b\"\u0000\u0000\u1228\u1227\u0001\u0000\u0000\u0000\u1229\u122a"+ - "\u0001\u0000\u0000\u0000\u122a\u1228\u0001\u0000\u0000\u0000\u122a\u122b"+ - "\u0001\u0000\u0000\u0000\u122b\u122c\u0001\u0000\u0000\u0000\u122c\u1267"+ - "\u0005\u02fe\u0000\u0000\u122d\u122e\u0005\u02fd\u0000\u0000\u122e\u1230"+ - "\u0003\u0210\u0108\u0000\u122f\u1231\b\"\u0000\u0000\u1230\u122f\u0001"+ - "\u0000\u0000\u0000\u1231\u1232\u0001\u0000\u0000\u0000\u1232\u1230\u0001"+ - "\u0000\u0000\u0000\u1232\u1233\u0001\u0000\u0000\u0000\u1233\u1234\u0001"+ - "\u0000\u0000\u0000\u1234\u1235\u0005\u02fd\u0000\u0000\u1235\u1236\u0003"+ - "\u0210\u0108\u0000\u1236\u1237\u0005\u02fd\u0000\u0000\u1237\u1267\u0001"+ - "\u0000\u0000\u0000\u1238\u1267\u0003\u01c0\u00e0\u0000\u1239\u1267\u0003"+ - "\u017c\u00be\u0000\u123a\u1267\u0003\u01c4\u00e2\u0000\u123b\u123c\u0005"+ - "\u0300\u0000\u0000\u123c\u123d\u0003\u01b8\u00dc\u0000\u123d\u123e\u0005"+ - "\u0301\u0000\u0000\u123e\u1267\u0001\u0000\u0000\u0000\u123f\u1240\u0003"+ - "\u01d0\u00e8\u0000\u1240\u1241\u0005\u030a\u0000\u0000\u1241\u1267\u0001"+ - "\u0000\u0000\u0000\u1242\u1243\u0007#\u0000\u0000\u1243\u1267\u0003\u01b8"+ - "\u00dc\u001f\u1244\u1245\u0007$\u0000\u0000\u1245\u1267\u0003\u01b8\u00dc"+ - "\u001e\u1246\u1247\u0007%\u0000\u0000\u1247\u1267\u0003\u01b8\u00dc\u0012"+ - "\u1248\u124a\u0003\u01ec\u00f6\u0000\u1249\u124b\u0003\u01a2\u00d1\u0000"+ - "\u124a\u1249\u0001\u0000\u0000\u0000\u124a\u124b\u0001\u0000\u0000\u0000"+ - "\u124b\u1267\u0001\u0000\u0000\u0000\u124c\u1267\u0003\u0210\u0108\u0000"+ - "\u124d\u124e\u0005?\u0000\u0000\u124e\u124f\u0005\u0300\u0000\u0000\u124f"+ - "\u1250\u0003\u01b8\u00dc\u0000\u1250\u1251\u0005\u001b\u0000\u0000\u1251"+ - "\u1252\u0003\u01e4\u00f2\u0000\u1252\u1253\u0005\u0301\u0000\u0000\u1253"+ - "\u1267\u0001\u0000\u0000\u0000\u1254\u1255\u0003\u0216\u010b\u0000\u1255"+ - "\u1256\u0005\u0309\u0000\u0000\u1256\u1257\u0003\u0218\u010c\u0000\u1257"+ - "\u1267\u0001\u0000\u0000\u0000\u1258\u1267\u0003\u01c2\u00e1\u0000\u1259"+ - "\u125a\u0003\u01e4\u00f2\u0000\u125a\u125b\u0003\u01b8\u00dc\n\u125b\u1267"+ - "\u0001\u0000\u0000\u0000\u125c\u1267\u0003\u01d6\u00eb\u0000\u125d\u1267"+ - "\u0003\u01ee\u00f7\u0000\u125e\u125f\u0005\u00d3\u0000\u0000\u125f\u1267"+ - "\u0003\u01b8\u00dc\u0004\u1260\u1267\u0005\u030d\u0000\u0000\u1261\u1262"+ - "\u0005\u0300\u0000\u0000\u1262\u1263\u0003\u0158\u00ac\u0000\u1263\u1264"+ - "\u0005\u0301\u0000\u0000\u1264\u1267\u0001\u0000\u0000\u0000\u1265\u1267"+ - "\u0003\u01ba\u00dd\u0000\u1266\u1218\u0001\u0000\u0000\u0000\u1266\u121a"+ - "\u0001\u0000\u0000\u0000\u1266\u121b\u0001\u0000\u0000\u0000\u1266\u121c"+ - "\u0001\u0000\u0000\u0000\u1266\u121d\u0001\u0000\u0000\u0000\u1266\u121e"+ - "\u0001\u0000\u0000\u0000\u1266\u121f\u0001\u0000\u0000\u0000\u1266\u1220"+ - "\u0001\u0000\u0000\u0000\u1266\u1221\u0001\u0000\u0000\u0000\u1266\u1222"+ - "\u0001\u0000\u0000\u0000\u1266\u1223\u0001\u0000\u0000\u0000\u1266\u1224"+ - "\u0001\u0000\u0000\u0000\u1266\u1225\u0001\u0000\u0000\u0000\u1266\u1226"+ - "\u0001\u0000\u0000\u0000\u1266\u122d\u0001\u0000\u0000\u0000\u1266\u1238"+ - "\u0001\u0000\u0000\u0000\u1266\u1239\u0001\u0000\u0000\u0000\u1266\u123a"+ - "\u0001\u0000\u0000\u0000\u1266\u123b\u0001\u0000\u0000\u0000\u1266\u123f"+ - "\u0001\u0000\u0000\u0000\u1266\u1242\u0001\u0000\u0000\u0000\u1266\u1244"+ - "\u0001\u0000\u0000\u0000\u1266\u1246\u0001\u0000\u0000\u0000\u1266\u1248"+ - "\u0001\u0000\u0000\u0000\u1266\u124c\u0001\u0000\u0000\u0000\u1266\u124d"+ - "\u0001\u0000\u0000\u0000\u1266\u1254\u0001\u0000\u0000\u0000\u1266\u1258"+ - "\u0001\u0000\u0000\u0000\u1266\u1259\u0001\u0000\u0000\u0000\u1266\u125c"+ - "\u0001\u0000\u0000\u0000\u1266\u125d\u0001\u0000\u0000\u0000\u1266\u125e"+ - "\u0001\u0000\u0000\u0000\u1266\u1260\u0001\u0000\u0000\u0000\u1266\u1261"+ - "\u0001\u0000\u0000\u0000\u1266\u1265\u0001\u0000\u0000\u0000\u1267\u12cf"+ - "\u0001\u0000\u0000\u0000\u1268\u1269\n\u001c\u0000\u0000\u1269\u126a\u0007"+ - "&\u0000\u0000\u126a\u12ce\u0003\u01b8\u00dc\u001d\u126b\u126c\n\u001b"+ - "\u0000\u0000\u126c\u126d\u0007\'\u0000\u0000\u126d\u12ce\u0003\u01b8\u00dc"+ - "\u001c\u126e\u126f\n\u001a\u0000\u0000\u126f\u1270\u0007(\u0000\u0000"+ - "\u1270\u12ce\u0003\u01b8\u00dc\u001b\u1271\u1272\n\u0019\u0000\u0000\u1272"+ - "\u1273\u0007)\u0000\u0000\u1273\u12ce\u0003\u01b8\u00dc\u001a\u1274\u1278"+ - "\n\u0018\u0000\u0000\u1275\u1276\u0005\u016d\u0000\u0000\u1276\u1279\u0005"+ - "\u0135\u0000\u0000\u1277\u1279\u0005\u0135\u0000\u0000\u1278\u1275\u0001"+ - "\u0000\u0000\u0000\u1278\u1277\u0001\u0000\u0000\u0000\u1279\u127a\u0001"+ - "\u0000\u0000\u0000\u127a\u12ce\u0003\u01b8\u00dc\u0019\u127b\u127d\n\u0017"+ - "\u0000\u0000\u127c\u127e\u0005\u016d\u0000\u0000\u127d\u127c\u0001\u0000"+ - "\u0000\u0000\u127d\u127e\u0001\u0000\u0000\u0000\u127e\u127f\u0001\u0000"+ - "\u0000\u0000\u127f\u1280\u0005+\u0000\u0000\u1280\u1281\u0003\u01b8\u00dc"+ - "\u0000\u1281\u1282\u0005\u0017\u0000\u0000\u1282\u1283\u0003\u01b8\u00dc"+ - "\u0018\u1283\u12ce\u0001\u0000\u0000\u0000\u1284\u1288\n\u0016\u0000\u0000"+ - "\u1285\u1286\u0005\u016d\u0000\u0000\u1286\u1289\u0005\u0109\u0000\u0000"+ - "\u1287\u1289\u0005\u0109\u0000\u0000\u1288\u1285\u0001\u0000\u0000\u0000"+ - "\u1288\u1287\u0001\u0000\u0000\u0000\u1289\u128a\u0001\u0000\u0000\u0000"+ - "\u128a\u12ce\u0003\u01b8\u00dc\u0017\u128b\u128c\n\u0015\u0000\u0000\u128c"+ - "\u128d\u0007*\u0000\u0000\u128d\u12ce\u0003\u01b8\u00dc\u0016\u128e\u128f"+ - "\n\u0013\u0000\u0000\u128f\u1291\u0005\u0121\u0000\u0000\u1290\u1292\u0005"+ - "\u016d\u0000\u0000\u1291\u1290\u0001\u0000\u0000\u0000\u1291\u1292\u0001"+ - "\u0000\u0000\u0000\u1292\u1293\u0001\u0000\u0000\u0000\u1293\u1294\u0005"+ - "\u00b8\u0000\u0000\u1294\u1295\u0005\u00ec\u0000\u0000\u1295\u12ce\u0003"+ - "\u01b8\u00dc\u0014\u1296\u1297\n\"\u0000\u0000\u1297\u1298\u0005\u0302"+ - "\u0000\u0000\u1298\u1299\u0003\u01b8\u00dc\u0000\u1299\u129a\u0005\u0303"+ - "\u0000\u0000\u129a\u12ce\u0001\u0000\u0000\u0000\u129b\u129c\n\u001d\u0000"+ - "\u0000\u129c\u12ce\u0005\u0315\u0000\u0000\u129d\u129e\n\u0014\u0000\u0000"+ - "\u129e\u12a3\u0005\u0121\u0000\u0000\u129f\u12a4\u0003\u01c0\u00e0\u0000"+ - "\u12a0\u12a4\u0005\u0172\u0000\u0000\u12a1\u12a2\u0005\u016d\u0000\u0000"+ - "\u12a2\u12a4\u0005\u0172\u0000\u0000\u12a3\u129f\u0001\u0000\u0000\u0000"+ - "\u12a3\u12a0\u0001\u0000\u0000\u0000\u12a3\u12a1\u0001\u0000\u0000\u0000"+ - "\u12a4\u12ce\u0001\u0000\u0000\u0000\u12a5\u12af\n\f\u0000\u0000\u12a6"+ - "\u12a8\u0005\u0302\u0000\u0000\u12a7\u12a9\u0003\u01b8\u00dc\u0000\u12a8"+ - "\u12a7\u0001\u0000\u0000\u0000\u12a8\u12a9\u0001\u0000\u0000\u0000\u12a9"+ - "\u12aa\u0001\u0000\u0000\u0000\u12aa\u12ac\u0005\u02fb\u0000\u0000\u12ab"+ - "\u12ad\u0003\u01b8\u00dc\u0000\u12ac\u12ab\u0001\u0000\u0000\u0000\u12ac"+ - "\u12ad\u0001\u0000\u0000\u0000\u12ad\u12ae\u0001\u0000\u0000\u0000\u12ae"+ - "\u12b0\u0005\u0303\u0000\u0000\u12af\u12a6\u0001\u0000\u0000\u0000\u12b0"+ - "\u12b1\u0001\u0000\u0000\u0000\u12b1\u12af\u0001\u0000\u0000\u0000\u12b1"+ - "\u12b2\u0001\u0000\u0000\u0000\u12b2\u12ce\u0001\u0000\u0000\u0000\u12b3"+ - "\u12b6\n\u000b\u0000\u0000\u12b4\u12b5\u0005\u02fc\u0000\u0000\u12b5\u12b7"+ - "\u0003\u01e4\u00f2\u0000\u12b6\u12b4\u0001\u0000\u0000\u0000\u12b7\u12b8"+ - "\u0001\u0000\u0000\u0000\u12b8\u12b6\u0001\u0000\u0000\u0000\u12b8\u12b9"+ - "\u0001\u0000\u0000\u0000\u12b9\u12ce\u0001\u0000\u0000\u0000\u12ba\u12bb"+ - "\n\t\u0000\u0000\u12bb\u12bc\u0005\u0121\u0000\u0000\u12bc\u12bd\u0005"+ - "\u017b\u0000\u0000\u12bd\u12be\u0005\u0300\u0000\u0000\u12be\u12bf\u0003"+ - "\u01e4\u00f2\u0000\u12bf\u12c0\u0005\u0301\u0000\u0000\u12c0\u12ce\u0001"+ - "\u0000\u0000\u0000\u12c1\u12c2\n\b\u0000\u0000\u12c2\u12c5\u0005\u0309"+ - "\u0000\u0000\u12c3\u12c6\u0003\u0210\u0108\u0000\u12c4\u12c6\u0005\u02ff"+ - "\u0000\u0000\u12c5\u12c3\u0001\u0000\u0000\u0000\u12c5\u12c4\u0001\u0000"+ - "\u0000\u0000\u12c6\u12ce\u0001\u0000\u0000\u0000\u12c7\u12c8\n\u0005\u0000"+ - "\u0000\u12c8\u12c9\u0005!\u0000\u0000\u12c9\u12ca\u0005\u0242\u0000\u0000"+ - "\u12ca\u12cb\u0005\u0290\u0000\u0000\u12cb\u12cc\u0001\u0000\u0000\u0000"+ - "\u12cc\u12ce\u0005\u030a\u0000\u0000\u12cd\u1268\u0001\u0000\u0000\u0000"+ - "\u12cd\u126b\u0001\u0000\u0000\u0000\u12cd\u126e\u0001\u0000\u0000\u0000"+ - "\u12cd\u1271\u0001\u0000\u0000\u0000\u12cd\u1274\u0001\u0000\u0000\u0000"+ - "\u12cd\u127b\u0001\u0000\u0000\u0000\u12cd\u1284\u0001\u0000\u0000\u0000"+ - "\u12cd\u128b\u0001\u0000\u0000\u0000\u12cd\u128e\u0001\u0000\u0000\u0000"+ - "\u12cd\u1296\u0001\u0000\u0000\u0000\u12cd\u129b\u0001\u0000\u0000\u0000"+ - "\u12cd\u129d\u0001\u0000\u0000\u0000\u12cd\u12a5\u0001\u0000\u0000\u0000"+ - "\u12cd\u12b3\u0001\u0000\u0000\u0000\u12cd\u12ba\u0001\u0000\u0000\u0000"+ - "\u12cd\u12c1\u0001\u0000\u0000\u0000\u12cd\u12c7\u0001\u0000\u0000\u0000"+ - "\u12ce\u12d1\u0001\u0000\u0000\u0000\u12cf\u12cd\u0001\u0000\u0000\u0000"+ - "\u12cf\u12d0\u0001\u0000\u0000\u0000\u12d0\u01b9\u0001\u0000\u0000\u0000"+ - "\u12d1\u12cf\u0001\u0000\u0000\u0000\u12d2\u12d3\u0005\u02fb\u0000\u0000"+ - "\u12d3\u12e1\u0005\u0345\u0000\u0000\u12d4\u12d5\u0005\u02fb\u0000\u0000"+ - "\u12d5\u12e1\u0003\u0210\u0108\u0000\u12d6\u12d7\u0005\u02fb\u0000\u0000"+ - "\u12d7\u12e1\u0003\u020c\u0106\u0000\u12d8\u12d9\u0005\u02fb\u0000\u0000"+ - "\u12d9\u12e1\u0005\u0307\u0000\u0000\u12da\u12db\u0005\u0336\u0000\u0000"+ - "\u12db\u12e1\u0005\u0345\u0000\u0000\u12dc\u12de\u0005\u0336\u0000\u0000"+ - "\u12dd\u12df\u0005\u0307\u0000\u0000\u12de\u12dd\u0001\u0000\u0000\u0000"+ - "\u12de\u12df\u0001\u0000\u0000\u0000\u12df\u12e1\u0001\u0000\u0000\u0000"+ - "\u12e0\u12d2\u0001\u0000\u0000\u0000\u12e0\u12d4\u0001\u0000\u0000\u0000"+ - "\u12e0\u12d6\u0001\u0000\u0000\u0000\u12e0\u12d8\u0001\u0000\u0000\u0000"+ - "\u12e0\u12da\u0001\u0000\u0000\u0000\u12e0\u12dc\u0001\u0000\u0000\u0000"+ - "\u12e1\u01bb\u0001\u0000\u0000\u0000\u12e2\u12e5\u0003\u01ba\u00dd\u0000"+ - "\u12e3\u12e5\u0005\u0307\u0000\u0000\u12e4\u12e2\u0001\u0000\u0000\u0000"+ - "\u12e4\u12e3\u0001\u0000\u0000\u0000\u12e5\u01bd\u0001\u0000\u0000\u0000"+ - "\u12e6\u12e9\u0003\u01ba\u00dd\u0000\u12e7\u12e9\u0005\u0306\u0000\u0000"+ - "\u12e8\u12e6\u0001\u0000\u0000\u0000\u12e8\u12e7\u0001\u0000\u0000\u0000"+ - "\u12e9\u01bf\u0001\u0000\u0000\u0000\u12ea\u12eb\u0006\u00e0\uffff\uffff"+ - "\u0000\u12eb\u12f0\u0005\u025a\u0000\u0000\u12ec\u12f0\u0005\u00da\u0000"+ - "\u0000\u12ed\u12ee\u0005\u016d\u0000\u0000\u12ee\u12f0\u0003\u01c0\u00e0"+ - "\u0003\u12ef\u12ea\u0001\u0000\u0000\u0000\u12ef\u12ec\u0001\u0000\u0000"+ - "\u0000\u12ef\u12ed\u0001\u0000\u0000\u0000\u12f0\u12f9\u0001\u0000\u0000"+ - "\u0000\u12f1\u12f2\n\u0002\u0000\u0000\u12f2\u12f3\u0005\u0017\u0000\u0000"+ - "\u12f3\u12f8\u0003\u01c0\u00e0\u0003\u12f4\u12f5\n\u0001\u0000\u0000\u12f5"+ - "\u12f6\u0005\u0187\u0000\u0000\u12f6\u12f8\u0003\u01c0\u00e0\u0002\u12f7"+ - "\u12f1\u0001\u0000\u0000\u0000\u12f7\u12f4\u0001\u0000\u0000\u0000\u12f8"+ - "\u12fb\u0001\u0000\u0000\u0000\u12f9\u12f7\u0001\u0000\u0000\u0000\u12f9"+ - "\u12fa\u0001\u0000\u0000\u0000\u12fa\u01c1\u0001\u0000\u0000\u0000\u12fb"+ - "\u12f9\u0001\u0000\u0000\u0000\u12fc\u12fd\u0005>\u0000\u0000\u12fd\u1303"+ - "\u0003\u01b8\u00dc\u0000\u12fe\u12ff\u0005\u0283\u0000\u0000\u12ff\u1300"+ - "\u0003\u01b8\u00dc\u0000\u1300\u1301\u0005\u0240\u0000\u0000\u1301\u1302"+ - "\u0003\u01b8\u00dc\u0000\u1302\u1304\u0001\u0000\u0000\u0000\u1303\u12fe"+ - "\u0001\u0000\u0000\u0000\u1304\u1305\u0001\u0000\u0000\u0000\u1305\u1303"+ - "\u0001\u0000\u0000\u0000\u1305\u1306\u0001\u0000\u0000\u0000\u1306\u1309"+ - "\u0001\u0000\u0000\u0000\u1307\u1308\u0005\u00c2\u0000\u0000\u1308\u130a"+ - "\u0003\u01b8\u00dc\u0000\u1309\u1307\u0001\u0000\u0000\u0000\u1309\u130a"+ - "\u0001\u0000\u0000\u0000\u130a\u130b\u0001\u0000\u0000\u0000\u130b\u130c"+ - "\u0005\u00c6\u0000\u0000\u130c\u131e\u0001\u0000\u0000\u0000\u130d\u1313"+ - "\u0005>\u0000\u0000\u130e\u130f\u0005\u0283\u0000\u0000\u130f\u1310\u0003"+ - "\u01f8\u00fc\u0000\u1310\u1311\u0005\u0240\u0000\u0000\u1311\u1312\u0003"+ - "\u01b8\u00dc\u0000\u1312\u1314\u0001\u0000\u0000\u0000\u1313\u130e\u0001"+ - "\u0000\u0000\u0000\u1314\u1315\u0001\u0000\u0000\u0000\u1315\u1313\u0001"+ - "\u0000\u0000\u0000\u1315\u1316\u0001\u0000\u0000\u0000\u1316\u1319\u0001"+ - "\u0000\u0000\u0000\u1317\u1318\u0005\u00c2\u0000\u0000\u1318\u131a\u0003"+ - "\u01b8\u00dc\u0000\u1319\u1317\u0001\u0000\u0000\u0000\u1319\u131a\u0001"+ - "\u0000\u0000\u0000\u131a\u131b\u0001\u0000\u0000\u0000\u131b\u131c\u0005"+ - "\u00c6\u0000\u0000\u131c\u131e\u0001\u0000\u0000\u0000\u131d\u12fc\u0001"+ - "\u0000\u0000\u0000\u131d\u130d\u0001\u0000\u0000\u0000\u131e\u01c3\u0001"+ - "\u0000\u0000\u0000\u131f\u1320\u0005\u0300\u0000\u0000\u1320\u1325\u0003"+ - "\u01b8\u00dc\u0000\u1321\u1322\u0005\u02fa\u0000\u0000\u1322\u1324\u0003"+ - "\u01b8\u00dc\u0000\u1323\u1321\u0001\u0000\u0000\u0000\u1324\u1327\u0001"+ - "\u0000\u0000\u0000\u1325\u1323\u0001\u0000\u0000\u0000\u1325\u1326\u0001"+ - "\u0000\u0000\u0000\u1326\u1328\u0001\u0000\u0000\u0000\u1327\u1325\u0001"+ - "\u0000\u0000\u0000\u1328\u1329\u0005\u0301\u0000\u0000\u1329\u01c5\u0001"+ - "\u0000\u0000\u0000\u132a\u132c\u0005\u0300\u0000\u0000\u132b\u132a\u0001"+ - "\u0000\u0000\u0000\u132b\u132c\u0001\u0000\u0000\u0000\u132c\u132d\u0001"+ - "\u0000\u0000\u0000\u132d\u1332\u0003\u01c4\u00e2\u0000\u132e\u132f\u0005"+ - "\u02fa\u0000\u0000\u132f\u1331\u0003\u01c4\u00e2\u0000\u1330\u132e\u0001"+ - "\u0000\u0000\u0000\u1331\u1334\u0001\u0000\u0000\u0000\u1332\u1330\u0001"+ - "\u0000\u0000\u0000\u1332\u1333\u0001\u0000\u0000\u0000\u1333\u1336\u0001"+ - "\u0000\u0000\u0000\u1334\u1332\u0001\u0000\u0000\u0000\u1335\u1337\u0005"+ - "\u0301\u0000\u0000\u1336\u1335\u0001\u0000\u0000\u0000\u1336\u1337\u0001"+ - "\u0000\u0000\u0000\u1337\u01c7\u0001\u0000\u0000\u0000\u1338\u133a\u0007"+ - "+\u0000\u0000\u1339\u1338\u0001\u0000\u0000\u0000\u1339\u133a\u0001\u0000"+ - "\u0000\u0000\u133a\u133c\u0001\u0000\u0000\u0000\u133b\u133d\u0003\u0210"+ - "\u0108\u0000\u133c\u133b\u0001\u0000\u0000\u0000\u133c\u133d\u0001\u0000"+ - "\u0000\u0000\u133d\u133e\u0001\u0000\u0000\u0000\u133e\u1340\u0003\u01e4"+ - "\u00f2\u0000\u133f\u1339\u0001\u0000\u0000\u0000\u133f\u1340\u0001\u0000"+ - "\u0000\u0000\u1340\u01c9\u0001\u0000\u0000\u0000\u1341\u1346\u0003\u01c8"+ - "\u00e4\u0000\u1342\u1343\u0005\u02fa\u0000\u0000\u1343\u1345\u0003\u01c8"+ - "\u00e4\u0000\u1344\u1342\u0001\u0000\u0000\u0000\u1345\u1348\u0001\u0000"+ - "\u0000\u0000\u1346\u1344\u0001\u0000\u0000\u0000\u1346\u1347\u0001\u0000"+ - "\u0000\u0000\u1347\u01cb\u0001\u0000\u0000\u0000\u1348\u1346\u0001\u0000"+ - "\u0000\u0000\u1349\u134e\u0003\u0210\u0108\u0000\u134a\u134b\u0005\u0300"+ - "\u0000\u0000\u134b\u134c\u0003\u01ca\u00e5\u0000\u134c\u134d\u0005\u0301"+ - "\u0000\u0000\u134d\u134f\u0001\u0000\u0000\u0000\u134e\u134a\u0001\u0000"+ - "\u0000\u0000\u134e\u134f\u0001\u0000\u0000\u0000\u134f\u01cd\u0001\u0000"+ - "\u0000\u0000\u1350\u1355\u0003\u01cc\u00e6\u0000\u1351\u1352\u0005\u02fa"+ - "\u0000\u0000\u1352\u1354\u0003\u01cc\u00e6\u0000\u1353\u1351\u0001\u0000"+ - "\u0000\u0000\u1354\u1357\u0001\u0000\u0000\u0000\u1355\u1353\u0001\u0000"+ - "\u0000\u0000\u1355\u1356\u0001\u0000\u0000\u0000\u1356\u01cf\u0001\u0000"+ - "\u0000\u0000\u1357\u1355\u0001\u0000\u0000\u0000\u1358\u13e9\u0005\u02d1"+ - "\u0000\u0000\u1359\u13e9\u0005\u02ea\u0000\u0000\u135a\u13e9\u0005,\u0000"+ - "\u0000\u135b\u13e9\u0005\u02d2\u0000\u0000\u135c\u1360\u0005.\u0000\u0000"+ - "\u135d\u135e\u0005\u0300\u0000\u0000\u135e\u135f\u0005\u0307\u0000\u0000"+ - "\u135f\u1361\u0005\u0301\u0000\u0000\u1360\u135d\u0001\u0000\u0000\u0000"+ - "\u1360\u1361\u0001\u0000\u0000\u0000\u1361\u13e9\u0001\u0000\u0000\u0000"+ - "\u1362\u1366\u0005\u02d3\u0000\u0000\u1363\u1364\u0005\u0300\u0000\u0000"+ - "\u1364\u1365\u0005\u0307\u0000\u0000\u1365\u1367\u0005\u0301\u0000\u0000"+ - "\u1366\u1363\u0001\u0000\u0000\u0000\u1366\u1367\u0001\u0000\u0000\u0000"+ - "\u1367\u13e9\u0001\u0000\u0000\u0000\u1368\u13e9\u0005\u02d4\u0000\u0000"+ - "\u1369\u13e9\u00052\u0000\u0000\u136a\u13e9\u0005\u02d5\u0000\u0000\u136b"+ - "\u13e9\u0005\u02d6\u0000\u0000\u136c\u1370\u0005E\u0000\u0000\u136d\u136e"+ - "\u0005\u0300\u0000\u0000\u136e\u136f\u0005\u0307\u0000\u0000\u136f\u1371"+ - "\u0005\u0301\u0000\u0000\u1370\u136d\u0001\u0000\u0000\u0000\u1370\u1371"+ - "\u0001\u0000\u0000\u0000\u1371\u13e9\u0001\u0000\u0000\u0000\u1372\u1376"+ - "\u0005G\u0000\u0000\u1373\u1374\u0005\u0300\u0000\u0000\u1374\u1375\u0005"+ - "\u0307\u0000\u0000\u1375\u1377\u0005\u0301\u0000\u0000\u1376\u1373\u0001"+ - "\u0000\u0000\u0000\u1376\u1377\u0001\u0000\u0000\u0000\u1377\u13e9\u0001"+ - "\u0000\u0000\u0000\u1378\u137c\u0005\u02d7\u0000\u0000\u1379\u137a\u0005"+ - "\u0300\u0000\u0000\u137a\u137b\u0005\u0307\u0000\u0000\u137b\u137d\u0005"+ - "\u0301\u0000\u0000\u137c\u1379\u0001\u0000\u0000\u0000\u137c\u137d\u0001"+ - "\u0000\u0000\u0000\u137d\u13e9\u0001\u0000\u0000\u0000\u137e\u13e9\u0005"+ - "\u02d8\u0000\u0000\u137f\u13e9\u0005\u02d9\u0000\u0000\u1380\u13e9\u0005"+ - "\u0093\u0000\u0000\u1381\u1387\u0005\u0099\u0000\u0000\u1382\u1383\u0005"+ - "\u0300\u0000\u0000\u1383\u1384\u0005\u0307\u0000\u0000\u1384\u1385\u0005"+ - "\u02fa\u0000\u0000\u1385\u1386\u0005\u0307\u0000\u0000\u1386\u1388\u0005"+ - "\u0301\u0000\u0000\u1387\u1382\u0001\u0000\u0000\u0000\u1387\u1388\u0001"+ - "\u0000\u0000\u0000\u1388\u13e9\u0001\u0000\u0000\u0000\u1389\u138a\u0005"+ - "\u00bb\u0000\u0000\u138a\u13e9\u0005\u01ae\u0000\u0000\u138b\u13e9\u0005"+ - "\u02da\u0000\u0000\u138c\u13e9\u0005\u02db\u0000\u0000\u138d\u13e9\u0005"+ - "\u02dc\u0000\u0000\u138e\u13e9\u0005\u011a\u0000\u0000\u138f\u13e9\u0005"+ - "\u02de\u0000\u0000\u1390\u13e9\u0005\u02dd\u0000\u0000\u1391\u13e9\u0005"+ - "\u02df\u0000\u0000\u1392\u13e9\u0005\u011b\u0000\u0000\u1393\u1395\u0005"+ - "\u011e\u0000\u0000\u1394\u1396\u0005\u00dc\u0000\u0000\u1395\u1394\u0001"+ - "\u0000\u0000\u0000\u1395\u1396\u0001\u0000\u0000\u0000\u1396\u1398\u0001"+ - "\u0000\u0000\u0000\u1397\u1399\u0005\u0307\u0000\u0000\u1398\u1397\u0001"+ - "\u0000\u0000\u0000\u1398\u1399\u0001\u0000\u0000\u0000\u1399\u13e9\u0001"+ - "\u0000\u0000\u0000\u139a\u13e9\u0005\u02e0\u0000\u0000\u139b\u13e9\u0005"+ - "\u02e1\u0000\u0000\u139c\u13e9\u0005\u02e2\u0000\u0000\u139d\u13e9\u0005"+ - "\u02e3\u0000\u0000\u139e\u13e9\u0005\u02e4\u0000\u0000\u139f\u13e9\u0005"+ - "\u02e5\u0000\u0000\u13a0\u13e9\u0005\u02e6\u0000\u0000\u13a1\u13a7\u0005"+ - "\u0177\u0000\u0000\u13a2\u13a3\u0005\u0300\u0000\u0000\u13a3\u13a4\u0005"+ - "\u0307\u0000\u0000\u13a4\u13a5\u0005\u02fa\u0000\u0000\u13a5\u13a6\u0005"+ - "\u0307\u0000\u0000\u13a6\u13a8\u0005\u0301\u0000\u0000\u13a7\u13a2\u0001"+ - "\u0000\u0000\u0000\u13a7\u13a8\u0001\u0000\u0000\u0000\u13a8\u13e9\u0001"+ - "\u0000\u0000\u0000\u13a9\u13e9\u0005\u01a2\u0000\u0000\u13aa\u13e9\u0005"+ - "\u02e7\u0000\u0000\u13ab\u13e9\u0005\u02e8\u0000\u0000\u13ac\u13e9\u0005"+ - "\u02e9\u0000\u0000\u13ad\u13e9\u0005\u01c0\u0000\u0000\u13ae\u13e9\u0005"+ - "\u02eb\u0000\u0000\u13af\u13e9\u0005\u02ec\u0000\u0000\u13b0\u13e9\u0005"+ - "\u02ed\u0000\u0000\u13b1\u13e9\u0005\u02ee\u0000\u0000\u13b2\u13e9\u0005"+ - "\u0210\u0000\u0000\u13b3\u13e9\u0005\u02ef\u0000\u0000\u13b4\u13e9\u0005"+ - "\u02f1\u0000\u0000\u13b5\u13b9\u0005\u0242\u0000\u0000\u13b6\u13b7\u0005"+ - "\u0300\u0000\u0000\u13b7\u13b8\u0005\u0307\u0000\u0000\u13b8\u13ba\u0005"+ - "\u0301\u0000\u0000\u13b9\u13b6\u0001\u0000\u0000\u0000\u13b9\u13ba\u0001"+ - "\u0000\u0000\u0000\u13ba\u13be\u0001\u0000\u0000\u0000\u13bb\u13bc\u0007"+ - ",\u0000\u0000\u13bc\u13bd\u0005\u0242\u0000\u0000\u13bd\u13bf\u0005\u0290"+ - "\u0000\u0000\u13be\u13bb\u0001\u0000\u0000\u0000\u13be\u13bf\u0001\u0000"+ - "\u0000\u0000\u13bf\u13e9\u0001\u0000\u0000\u0000\u13c0\u13c4\u0005\u0243"+ - "\u0000\u0000\u13c1\u13c2\u0005\u0300\u0000\u0000\u13c2\u13c3\u0005\u0307"+ - "\u0000\u0000\u13c3\u13c5\u0005\u0301\u0000\u0000\u13c4\u13c1\u0001\u0000"+ - "\u0000\u0000\u13c4\u13c5\u0001\u0000\u0000\u0000\u13c5\u13c9\u0001\u0000"+ - "\u0000\u0000\u13c6\u13c7\u0007,\u0000\u0000\u13c7\u13c8\u0005\u0242\u0000"+ - "\u0000\u13c8\u13ca\u0005\u0290\u0000\u0000\u13c9\u13c6\u0001\u0000\u0000"+ - "\u0000\u13c9\u13ca\u0001\u0000\u0000\u0000\u13ca\u13e9\u0001\u0000\u0000"+ - "\u0000\u13cb\u13cf\u0005\u02f3\u0000\u0000\u13cc\u13cd\u0005\u0300\u0000"+ - "\u0000\u13cd\u13ce\u0005\u0307\u0000\u0000\u13ce\u13d0\u0005\u0301\u0000"+ - "\u0000\u13cf\u13cc\u0001\u0000\u0000\u0000\u13cf\u13d0\u0001\u0000\u0000"+ - "\u0000\u13d0\u13e9\u0001\u0000\u0000\u0000\u13d1\u13d5\u0005\u02f2\u0000"+ - "\u0000\u13d2\u13d3\u0005\u0300\u0000\u0000\u13d3\u13d4\u0005\u0307\u0000"+ - "\u0000\u13d4\u13d6\u0005\u0301\u0000\u0000\u13d5\u13d2\u0001\u0000\u0000"+ - "\u0000\u13d5\u13d6\u0001\u0000\u0000\u0000\u13d6\u13e9\u0001\u0000\u0000"+ - "\u0000\u13d7\u13e9\u0005\u02f4\u0000\u0000\u13d8\u13e9\u0005\u02f5\u0000"+ - "\u0000\u13d9\u13e9\u0005\u02f6\u0000\u0000\u13da\u13e9\u0005\u02f7\u0000"+ - "\u0000\u13db\u13df\u0005\u02f8\u0000\u0000\u13dc\u13dd\u0005\u0300\u0000"+ - "\u0000\u13dd\u13de\u0005\u0307\u0000\u0000\u13de\u13e0\u0005\u0301\u0000"+ - "\u0000\u13df\u13dc\u0001\u0000\u0000\u0000\u13df\u13e0\u0001\u0000\u0000"+ - "\u0000\u13e0\u13e9\u0001\u0000\u0000\u0000\u13e1\u13e5\u0005\u027c\u0000"+ - "\u0000\u13e2\u13e3\u0005\u0300\u0000\u0000\u13e3\u13e4\u0005\u0307\u0000"+ - "\u0000\u13e4\u13e6\u0005\u0301\u0000\u0000\u13e5\u13e2\u0001\u0000\u0000"+ - "\u0000\u13e5\u13e6\u0001\u0000\u0000\u0000\u13e6\u13e9\u0001\u0000\u0000"+ - "\u0000\u13e7\u13e9\u0005\u02f9\u0000\u0000\u13e8\u1358\u0001\u0000\u0000"+ - "\u0000\u13e8\u1359\u0001\u0000\u0000\u0000\u13e8\u135a\u0001\u0000\u0000"+ - "\u0000\u13e8\u135b\u0001\u0000\u0000\u0000\u13e8\u135c\u0001\u0000\u0000"+ - "\u0000\u13e8\u1362\u0001\u0000\u0000\u0000\u13e8\u1368\u0001\u0000\u0000"+ - "\u0000\u13e8\u1369\u0001\u0000\u0000\u0000\u13e8\u136a\u0001\u0000\u0000"+ - "\u0000\u13e8\u136b\u0001\u0000\u0000\u0000\u13e8\u136c\u0001\u0000\u0000"+ - "\u0000\u13e8\u1372\u0001\u0000\u0000\u0000\u13e8\u1378\u0001\u0000\u0000"+ - "\u0000\u13e8\u137e\u0001\u0000\u0000\u0000\u13e8\u137f\u0001\u0000\u0000"+ - "\u0000\u13e8\u1380\u0001\u0000\u0000\u0000\u13e8\u1381\u0001\u0000\u0000"+ - "\u0000\u13e8\u1389\u0001\u0000\u0000\u0000\u13e8\u138b\u0001\u0000\u0000"+ - "\u0000\u13e8\u138c\u0001\u0000\u0000\u0000\u13e8\u138d\u0001\u0000\u0000"+ - "\u0000\u13e8\u138e\u0001\u0000\u0000\u0000\u13e8\u138f\u0001\u0000\u0000"+ - "\u0000\u13e8\u1390\u0001\u0000\u0000\u0000\u13e8\u1391\u0001\u0000\u0000"+ - "\u0000\u13e8\u1392\u0001\u0000\u0000\u0000\u13e8\u1393\u0001\u0000\u0000"+ - "\u0000\u13e8\u139a\u0001\u0000\u0000\u0000\u13e8\u139b\u0001\u0000\u0000"+ - "\u0000\u13e8\u139c\u0001\u0000\u0000\u0000\u13e8\u139d\u0001\u0000\u0000"+ - "\u0000\u13e8\u139e\u0001\u0000\u0000\u0000\u13e8\u139f\u0001\u0000\u0000"+ - "\u0000\u13e8\u13a0\u0001\u0000\u0000\u0000\u13e8\u13a1\u0001\u0000\u0000"+ - "\u0000\u13e8\u13a9\u0001\u0000\u0000\u0000\u13e8\u13aa\u0001\u0000\u0000"+ - "\u0000\u13e8\u13ab\u0001\u0000\u0000\u0000\u13e8\u13ac\u0001\u0000\u0000"+ - "\u0000\u13e8\u13ad\u0001\u0000\u0000\u0000\u13e8\u13ae\u0001\u0000\u0000"+ - "\u0000\u13e8\u13af\u0001\u0000\u0000\u0000\u13e8\u13b0\u0001\u0000\u0000"+ - "\u0000\u13e8\u13b1\u0001\u0000\u0000\u0000\u13e8\u13b2\u0001\u0000\u0000"+ - "\u0000\u13e8\u13b3\u0001\u0000\u0000\u0000\u13e8\u13b4\u0001\u0000\u0000"+ - "\u0000\u13e8\u13b5\u0001\u0000\u0000\u0000\u13e8\u13c0\u0001\u0000\u0000"+ - "\u0000\u13e8\u13cb\u0001\u0000\u0000\u0000\u13e8\u13d1\u0001\u0000\u0000"+ - "\u0000\u13e8\u13d7\u0001\u0000\u0000\u0000\u13e8\u13d8\u0001\u0000\u0000"+ - "\u0000\u13e8\u13d9\u0001\u0000\u0000\u0000\u13e8\u13da\u0001\u0000\u0000"+ - "\u0000\u13e8\u13db\u0001\u0000\u0000\u0000\u13e8\u13e1\u0001\u0000\u0000"+ - "\u0000\u13e8\u13e7\u0001\u0000\u0000\u0000\u13e9\u01d1\u0001\u0000\u0000"+ - "\u0000\u13ea\u13eb\u0007-\u0000\u0000\u13eb\u01d3\u0001\u0000\u0000\u0000"+ - "\u13ec\u13f1\u0001\u0000\u0000\u0000\u13ed\u13ee\u0005\u0121\u0000\u0000"+ - "\u13ee\u13f1\u0005\u017b\u0000\u0000\u13ef\u13f1\u0005\u0010\u0000\u0000"+ - "\u13f0\u13ec\u0001\u0000\u0000\u0000\u13f0\u13ed\u0001\u0000\u0000\u0000"+ - "\u13f0\u13ef\u0001\u0000\u0000\u0000\u13f1\u01d5\u0001\u0000\u0000\u0000"+ - "\u13f2\u13f3\u0003\u0210\u0108\u0000\u13f3\u13f5\u0005\u0300\u0000\u0000"+ - "\u13f4\u13f6\u0007\u001e\u0000\u0000\u13f5\u13f4\u0001\u0000\u0000\u0000"+ - "\u13f5\u13f6\u0001\u0000\u0000\u0000\u13f6\u13f7\u0001\u0000\u0000\u0000"+ - "\u13f7\u13fc\u0003\u01b8\u00dc\u0000\u13f8\u13f9\u0005\u02fa\u0000\u0000"+ - "\u13f9\u13fb\u0003\u01b8\u00dc\u0000\u13fa\u13f8\u0001\u0000\u0000\u0000"+ - "\u13fb\u13fe\u0001\u0000\u0000\u0000\u13fc\u13fa\u0001\u0000\u0000\u0000"+ - "\u13fc\u13fd\u0001\u0000\u0000\u0000\u13fd\u1400\u0001\u0000\u0000\u0000"+ - "\u13fe\u13fc\u0001\u0000\u0000\u0000\u13ff\u1401\u0003\u01a6\u00d3\u0000"+ - "\u1400\u13ff\u0001\u0000\u0000\u0000\u1400\u1401\u0001\u0000\u0000\u0000"+ - "\u1401\u1402\u0001\u0000\u0000\u0000\u1402\u1409\u0005\u0301\u0000\u0000"+ - "\u1403\u1404\u0005\u00dd\u0000\u0000\u1404\u1405\u0005\u0300\u0000\u0000"+ - "\u1405\u1406\u0005\u0285\u0000\u0000\u1406\u1407\u0003\u0182\u00c1\u0000"+ - "\u1407\u1408\u0005\u0301\u0000\u0000\u1408\u140a\u0001\u0000\u0000\u0000"+ - "\u1409\u1403\u0001\u0000\u0000\u0000\u1409\u140a\u0001\u0000\u0000\u0000"+ - "\u140a\u1432\u0001\u0000\u0000\u0000\u140b\u140c\u0003\u0210\u0108\u0000"+ - "\u140c\u140d\u0005\u0300\u0000\u0000\u140d\u140e\u0005\u02ff\u0000\u0000"+ - "\u140e\u1415\u0005\u0301\u0000\u0000\u140f\u1410\u0005\u00dd\u0000\u0000"+ - "\u1410\u1411\u0005\u0300\u0000\u0000\u1411\u1412\u0005\u0285\u0000\u0000"+ - "\u1412\u1413\u0003\u0182\u00c1\u0000\u1413\u1414\u0005\u0301\u0000\u0000"+ - "\u1414\u1416\u0001\u0000\u0000\u0000\u1415\u140f\u0001\u0000\u0000\u0000"+ - "\u1415\u1416\u0001\u0000\u0000\u0000\u1416\u1432\u0001\u0000\u0000\u0000"+ - "\u1417\u1418\u0003\u0210\u0108\u0000\u1418\u1421\u0005\u0300\u0000\u0000"+ - "\u1419\u141e\u0003\u01b8\u00dc\u0000\u141a\u141b\u0005\u02fa\u0000\u0000"+ - "\u141b\u141d\u0003\u01b8\u00dc\u0000\u141c\u141a\u0001\u0000\u0000\u0000"+ - "\u141d\u1420\u0001\u0000\u0000\u0000\u141e\u141c\u0001\u0000\u0000\u0000"+ - "\u141e\u141f\u0001\u0000\u0000\u0000\u141f\u1422\u0001\u0000\u0000\u0000"+ - "\u1420\u141e\u0001\u0000\u0000\u0000\u1421\u1419\u0001\u0000\u0000\u0000"+ - "\u1421\u1422\u0001\u0000\u0000\u0000\u1422\u1423\u0001\u0000\u0000\u0000"+ - "\u1423\u1424\u0005\u0301\u0000\u0000\u1424\u1425\u0005\u0289\u0000\u0000"+ - "\u1425\u1426\u0005\u00fa\u0000\u0000\u1426\u1427\u0005\u0300\u0000\u0000"+ - "\u1427\u1428\u0003\u01a6\u00d3\u0000\u1428\u142f\u0005\u0301\u0000\u0000"+ - "\u1429\u142a\u0005\u00dd\u0000\u0000\u142a\u142b\u0005\u0300\u0000\u0000"+ - "\u142b\u142c\u0005\u0285\u0000\u0000\u142c\u142d\u0003\u0182\u00c1\u0000"+ - "\u142d\u142e\u0005\u0301\u0000\u0000\u142e\u1430\u0001\u0000\u0000\u0000"+ - "\u142f\u1429\u0001\u0000\u0000\u0000\u142f\u1430\u0001\u0000\u0000\u0000"+ - "\u1430\u1432\u0001\u0000\u0000\u0000\u1431\u13f2\u0001\u0000\u0000\u0000"+ - "\u1431\u140b\u0001\u0000\u0000\u0000\u1431\u1417\u0001\u0000\u0000\u0000"+ - "\u1432\u01d7\u0001\u0000\u0000\u0000\u1433\u1436\u0005\u030a\u0000\u0000"+ - "\u1434\u1436\u0003\u0210\u0108\u0000\u1435\u1433\u0001\u0000\u0000\u0000"+ - "\u1435\u1434\u0001\u0000\u0000\u0000\u1436\u01d9\u0001\u0000\u0000\u0000"+ - "\u1437\u143c\u0003\u01d8\u00ec\u0000\u1438\u1439\u0005\u02fa\u0000\u0000"+ - "\u1439\u143b\u0003\u01d8\u00ec\u0000\u143a\u1438\u0001\u0000\u0000\u0000"+ - "\u143b\u143e\u0001\u0000\u0000\u0000\u143c\u143a\u0001\u0000\u0000\u0000"+ - "\u143c\u143d\u0001\u0000\u0000\u0000\u143d\u01db\u0001\u0000\u0000\u0000"+ - "\u143e\u143c\u0001\u0000\u0000\u0000\u143f\u1444\u0003\u0210\u0108\u0000"+ - "\u1440\u1441\u0005\u02fa\u0000\u0000\u1441\u1443\u0003\u0210\u0108\u0000"+ - "\u1442\u1440\u0001\u0000\u0000\u0000\u1443\u1446\u0001\u0000\u0000\u0000"+ - "\u1444\u1442\u0001\u0000\u0000\u0000\u1444\u1445\u0001\u0000\u0000\u0000"+ - "\u1445\u01dd\u0001\u0000\u0000\u0000\u1446\u1444\u0001\u0000\u0000\u0000"+ - "\u1447\u144a\u0003\u0210\u0108\u0000\u1448\u1449\u0005\u0319\u0000\u0000"+ - "\u1449\u144b\u0003\u020a\u0105\u0000\u144a\u1448\u0001\u0000\u0000\u0000"+ - "\u144a\u144b\u0001\u0000\u0000\u0000\u144b\u01df\u0001\u0000\u0000\u0000"+ - "\u144c\u1451\u0003\u01de\u00ef\u0000\u144d\u144e\u0005\u02fa\u0000\u0000"+ - "\u144e\u1450\u0003\u01de\u00ef\u0000\u144f\u144d\u0001\u0000\u0000\u0000"+ - "\u1450\u1453\u0001\u0000\u0000\u0000\u1451\u144f\u0001\u0000\u0000\u0000"+ - "\u1451\u1452\u0001\u0000\u0000\u0000\u1452\u01e1\u0001\u0000\u0000\u0000"+ - "\u1453\u1451\u0001\u0000\u0000\u0000\u1454\u1455\u0003\u0210\u0108\u0000"+ - "\u1455\u01e3\u0001\u0000\u0000\u0000\u1456\u1459\u0003\u01d0\u00e8\u0000"+ - "\u1457\u1459\u0003\u0210\u0108\u0000\u1458\u1456\u0001\u0000\u0000\u0000"+ - "\u1458\u1457\u0001\u0000\u0000\u0000\u1459\u1461\u0001\u0000\u0000\u0000"+ - "\u145a\u145c\u0005\u0302\u0000\u0000\u145b\u145d\u0005\u0307\u0000\u0000"+ - "\u145c\u145b\u0001\u0000\u0000\u0000\u145c\u145d\u0001\u0000\u0000\u0000"+ - "\u145d\u145e\u0001\u0000\u0000\u0000\u145e\u1460\u0005\u0303\u0000\u0000"+ - "\u145f\u145a\u0001\u0000\u0000\u0000\u1460\u1463\u0001\u0000\u0000\u0000"+ - "\u1461\u145f\u0001\u0000\u0000\u0000\u1461\u1462\u0001\u0000\u0000\u0000"+ - "\u1462\u01e5\u0001\u0000\u0000\u0000\u1463\u1461\u0001\u0000\u0000\u0000"+ - "\u1464\u1469\u0003\u01e4\u00f2\u0000\u1465\u1466\u0005\u02fa\u0000\u0000"+ - "\u1466\u1468\u0003\u01e4\u00f2\u0000\u1467\u1465\u0001\u0000\u0000\u0000"+ - "\u1468\u146b\u0001\u0000\u0000\u0000\u1469\u1467\u0001\u0000\u0000\u0000"+ - "\u1469\u146a\u0001\u0000\u0000\u0000\u146a\u01e7\u0001\u0000\u0000\u0000"+ - "\u146b\u1469\u0001\u0000\u0000\u0000\u146c\u146f\u0007.\u0000\u0000\u146d"+ - "\u146f\u0003\u0210\u0108\u0000\u146e\u146c\u0001\u0000\u0000\u0000\u146e"+ - "\u146d\u0001\u0000\u0000\u0000\u146f\u01e9\u0001\u0000\u0000\u0000\u1470"+ - "\u1471\u0003\u0210\u0108\u0000\u1471\u01eb\u0001\u0000\u0000\u0000\u1472"+ - "\u1473\u0003\u01ea\u00f5\u0000\u1473\u1474\u0005\u0300\u0000\u0000\u1474"+ - "\u1475\u0005\u027e\u0000\u0000\u1475\u1476\u0003\u01b8\u00dc\u0000\u1476"+ - "\u1477\u0005\u0301\u0000\u0000\u1477\u1497\u0001\u0000\u0000\u0000\u1478"+ - "\u1479\u0003\u01ea\u00f5\u0000\u1479\u1487\u0005\u0300\u0000\u0000\u147a"+ - "\u147f\u0003\u01b8\u00dc\u0000\u147b\u147c\u0005\u02fa\u0000\u0000\u147c"+ - "\u147e\u0003\u01b8\u00dc\u0000\u147d\u147b\u0001\u0000\u0000\u0000\u147e"+ - "\u1481\u0001\u0000\u0000\u0000\u147f\u147d\u0001\u0000\u0000\u0000\u147f"+ - "\u1480\u0001\u0000\u0000\u0000\u1480\u1485\u0001\u0000\u0000\u0000\u1481"+ - "\u147f\u0001\u0000\u0000\u0000\u1482\u1483\u0005\u02fa\u0000\u0000\u1483"+ - "\u1484\u0005\u027e\u0000\u0000\u1484\u1486\u0003\u01b8\u00dc\u0000\u1485"+ - "\u1482\u0001\u0000\u0000\u0000\u1485\u1486\u0001\u0000\u0000\u0000\u1486"+ - "\u1488\u0001\u0000\u0000\u0000\u1487\u147a\u0001\u0000\u0000\u0000\u1487"+ - "\u1488\u0001\u0000\u0000\u0000\u1488\u1489\u0001\u0000\u0000\u0000\u1489"+ - "\u148a\u0005\u0301\u0000\u0000\u148a\u1497\u0001\u0000\u0000\u0000\u148b"+ - "\u148c\u0003\u01ea\u00f5\u0000\u148c\u148d\u0005\u0300\u0000\u0000\u148d"+ - "\u148e\u0003\u0212\u0109\u0000\u148e\u148f\u0005\u00ec\u0000\u0000\u148f"+ - "\u1492\u0003\u01b8\u00dc\u0000\u1490\u1491\u0005\u00e3\u0000\u0000\u1491"+ - "\u1493\u0003\u01b8\u00dc\u0000\u1492\u1490\u0001\u0000\u0000\u0000\u1492"+ - "\u1493\u0001\u0000\u0000\u0000\u1493\u1494\u0001\u0000\u0000\u0000\u1494"+ - "\u1495\u0005\u0301\u0000\u0000\u1495\u1497\u0001\u0000\u0000\u0000\u1496"+ - "\u1472\u0001\u0000\u0000\u0000\u1496\u1478\u0001\u0000\u0000\u0000\u1496"+ - "\u148b\u0001\u0000\u0000\u0000\u1497\u01ed\u0001\u0000\u0000\u0000\u1498"+ - "\u1499\u0005\u001a\u0000\u0000\u1499\u14a2\u0005\u0302\u0000\u0000\u149a"+ - "\u149f\u0003\u01b8\u00dc\u0000\u149b\u149c\u0005\u02fa\u0000\u0000\u149c"+ - "\u149e\u0003\u01b8\u00dc\u0000\u149d\u149b\u0001\u0000\u0000\u0000\u149e"+ - "\u14a1\u0001\u0000\u0000\u0000\u149f\u149d\u0001\u0000\u0000\u0000\u149f"+ - "\u14a0\u0001\u0000\u0000\u0000\u14a0\u14a3\u0001\u0000\u0000\u0000\u14a1"+ - "\u149f\u0001\u0000\u0000\u0000\u14a2\u149a\u0001\u0000\u0000\u0000\u14a2"+ - "\u14a3\u0001\u0000\u0000\u0000\u14a3\u14a4\u0001\u0000\u0000\u0000\u14a4"+ - "\u14a5\u0005\u0303\u0000\u0000\u14a5\u01ef\u0001\u0000\u0000\u0000\u14a6"+ - "\u14a8\u0006\u00f8\uffff\uffff\u0000\u14a7\u14a9\u0005\u0181\u0000\u0000"+ - "\u14a8\u14a7\u0001\u0000\u0000\u0000\u14a8\u14a9\u0001\u0000\u0000\u0000"+ - "\u14a9\u14aa\u0001\u0000\u0000\u0000\u14aa\u14ac\u0003\u01e2\u00f1\u0000"+ - "\u14ab\u14ad\u0005\u02ff\u0000\u0000\u14ac\u14ab\u0001\u0000\u0000\u0000"+ - "\u14ac\u14ad\u0001\u0000\u0000\u0000\u14ad\u14af\u0001\u0000\u0000\u0000"+ - "\u14ae\u14b0\u0003\u01f2\u00f9\u0000\u14af\u14ae\u0001\u0000\u0000\u0000"+ - "\u14af\u14b0\u0001\u0000\u0000\u0000\u14b0\u14c4\u0001\u0000\u0000\u0000"+ - "\u14b1\u14b2\u0005\u0239\u0000\u0000\u14b2\u14b3\u0003\u0212\u0109\u0000"+ - "\u14b3\u14b4\u0005\u0300\u0000\u0000\u14b4\u14b9\u0003\u01b8\u00dc\u0000"+ - "\u14b5\u14b6\u0005\u02fa\u0000\u0000\u14b6\u14b8\u0003\u01b8\u00dc\u0000"+ - "\u14b7\u14b5\u0001\u0000\u0000\u0000\u14b8\u14bb\u0001\u0000\u0000\u0000"+ - "\u14b9\u14b7\u0001\u0000\u0000\u0000\u14b9\u14ba\u0001\u0000\u0000\u0000"+ - "\u14ba\u14bc\u0001\u0000\u0000\u0000\u14bb\u14b9\u0001\u0000\u0000\u0000"+ - "\u14bc\u14c2\u0005\u0301\u0000\u0000\u14bd\u14be\u0005\u01d5\u0000\u0000"+ - "\u14be\u14bf\u0005\u0300\u0000\u0000\u14bf\u14c0\u0003\u0212\u0109\u0000"+ - "\u14c0\u14c1\u0005\u0301\u0000\u0000\u14c1\u14c3\u0001\u0000\u0000\u0000"+ - "\u14c2\u14bd\u0001\u0000\u0000\u0000\u14c2\u14c3\u0001\u0000\u0000\u0000"+ - "\u14c3\u14c5\u0001\u0000\u0000\u0000\u14c4\u14b1\u0001\u0000\u0000\u0000"+ - "\u14c4\u14c5\u0001\u0000\u0000\u0000\u14c5\u1511\u0001\u0000\u0000\u0000"+ - "\u14c6\u14c8\u0005\u012e\u0000\u0000\u14c7\u14c6\u0001\u0000\u0000\u0000"+ - "\u14c7\u14c8\u0001\u0000\u0000\u0000\u14c8\u14c9\u0001\u0000\u0000\u0000"+ - "\u14c9\u14ca\u0005\u0300\u0000\u0000\u14ca\u14cb\u0003\u0002\u0001\u0000"+ - "\u14cb\u14cd\u0005\u0301\u0000\u0000\u14cc\u14ce\u0005\u001b\u0000\u0000"+ - "\u14cd\u14cc\u0001\u0000\u0000\u0000\u14cd\u14ce\u0001\u0000\u0000\u0000"+ - "\u14ce\u14cf\u0001\u0000\u0000\u0000\u14cf\u14db\u0003\u021a\u010d\u0000"+ - "\u14d0\u14d1\u0005\u0300\u0000\u0000\u14d1\u14d6\u0003\u021c\u010e\u0000"+ - "\u14d2\u14d3\u0005\u02fa\u0000\u0000\u14d3\u14d5\u0003\u021c\u010e\u0000"+ - "\u14d4\u14d2\u0001\u0000\u0000\u0000\u14d5\u14d8\u0001\u0000\u0000\u0000"+ - "\u14d6\u14d4\u0001\u0000\u0000\u0000\u14d6\u14d7\u0001\u0000\u0000\u0000"+ - "\u14d7\u14d9\u0001\u0000\u0000\u0000\u14d8\u14d6\u0001\u0000\u0000\u0000"+ - "\u14d9\u14da\u0005\u0301\u0000\u0000\u14da\u14dc\u0001\u0000\u0000\u0000"+ - "\u14db\u14d0\u0001\u0000\u0000\u0000\u14db\u14dc\u0001\u0000\u0000\u0000"+ - "\u14dc\u1511\u0001\u0000\u0000\u0000\u14dd\u14df\u0005\u012e\u0000\u0000"+ - "\u14de\u14dd\u0001\u0000\u0000\u0000\u14de\u14df\u0001\u0000\u0000\u0000"+ - "\u14df\u14e0\u0001\u0000\u0000\u0000\u14e0\u14e3\u0003\u01ec\u00f6\u0000"+ - "\u14e1\u14e2\u0005\u0288\u0000\u0000\u14e2\u14e4\u0005\u018a\u0000\u0000"+ - "\u14e3\u14e1\u0001\u0000\u0000\u0000\u14e3\u14e4\u0001\u0000\u0000\u0000"+ - "\u14e4\u14e6\u0001\u0000\u0000\u0000\u14e5\u14e7\u0003\u01f2\u00f9\u0000"+ - "\u14e6\u14e5\u0001\u0000\u0000\u0000\u14e6\u14e7\u0001\u0000\u0000\u0000"+ - "\u14e7\u1511\u0001\u0000\u0000\u0000\u14e8\u14ea\u0005\u012e\u0000\u0000"+ - "\u14e9\u14e8\u0001\u0000\u0000\u0000\u14e9\u14ea\u0001\u0000\u0000\u0000"+ - "\u14ea\u14eb\u0001\u0000\u0000\u0000\u14eb\u14ec\u0003\u01ec\u00f6\u0000"+ - "\u14ec\u14ed\u0005\u001b\u0000\u0000\u14ed\u14ee\u0005\u0300\u0000\u0000"+ - "\u14ee\u14f3\u0003\u021e\u010f\u0000\u14ef\u14f0\u0005\u02fa\u0000\u0000"+ - "\u14f0\u14f2\u0003\u021e\u010f\u0000\u14f1\u14ef\u0001\u0000\u0000\u0000"+ - "\u14f2\u14f5\u0001\u0000\u0000\u0000\u14f3\u14f1\u0001\u0000\u0000\u0000"+ - "\u14f3\u14f4\u0001\u0000\u0000\u0000\u14f4\u14f6\u0001\u0000\u0000\u0000"+ - "\u14f5\u14f3\u0001\u0000\u0000\u0000\u14f6\u14f7\u0005\u0301\u0000\u0000"+ - "\u14f7\u1511\u0001\u0000\u0000\u0000\u14f8\u14fa\u0005\u012e\u0000\u0000"+ - "\u14f9\u14f8\u0001\u0000\u0000\u0000\u14f9\u14fa\u0001\u0000\u0000\u0000"+ - "\u14fa\u14fb\u0001\u0000\u0000\u0000\u14fb\u14fc\u0005\u01ef\u0000\u0000"+ - "\u14fc\u14fd\u0005\u00ec\u0000\u0000\u14fd\u14fe\u0005\u0300\u0000\u0000"+ - "\u14fe\u14ff\u0003\u01ec\u00f6\u0000\u14ff\u150c\u0005\u0301\u0000\u0000"+ - "\u1500\u1501\u0005\u001b\u0000\u0000\u1501\u1502\u0005\u0300\u0000\u0000"+ - "\u1502\u1507\u0003\u021e\u010f\u0000\u1503\u1504\u0005\u02fa\u0000\u0000"+ - "\u1504\u1506\u0003\u021e\u010f\u0000\u1505\u1503\u0001\u0000\u0000\u0000"+ - "\u1506\u1509\u0001\u0000\u0000\u0000\u1507\u1505\u0001\u0000\u0000\u0000"+ - "\u1507\u1508\u0001\u0000\u0000\u0000\u1508\u150a\u0001\u0000\u0000\u0000"+ - "\u1509\u1507\u0001\u0000\u0000\u0000\u150a\u150b\u0005\u0301\u0000\u0000"+ - "\u150b\u150d\u0001\u0000\u0000\u0000\u150c\u1500\u0001\u0000\u0000\u0000"+ - "\u150c\u150d\u0001\u0000\u0000\u0000\u150d\u150e\u0001\u0000\u0000\u0000"+ - "\u150e\u150f\u0005\u0301\u0000\u0000\u150f\u1511\u0001\u0000\u0000\u0000"+ - "\u1510\u14a6\u0001\u0000\u0000\u0000\u1510\u14c7\u0001\u0000\u0000\u0000"+ - "\u1510\u14de\u0001\u0000\u0000\u0000\u1510\u14e9\u0001\u0000\u0000\u0000"+ - "\u1510\u14f9\u0001\u0000\u0000\u0000\u1511\u1523\u0001\u0000\u0000\u0000"+ - "\u1512\u1514\n\u0001\u0000\u0000\u1513\u1515\u0005\u0161\u0000\u0000\u1514"+ - "\u1513\u0001\u0000\u0000\u0000\u1514\u1515\u0001\u0000\u0000\u0000\u1515"+ - "\u1516\u0001\u0000\u0000\u0000\u1516\u1518\u0003\u01f4\u00fa\u0000\u1517"+ - "\u1519\u0005\u0300\u0000\u0000\u1518\u1517\u0001\u0000\u0000\u0000\u1518"+ - "\u1519\u0001\u0000\u0000\u0000\u1519\u151a\u0001\u0000\u0000\u0000\u151a"+ - "\u151c\u0003\u01f0\u00f8\u0000\u151b\u151d\u0003\u01f6\u00fb\u0000\u151c"+ - "\u151b\u0001\u0000\u0000\u0000\u151c\u151d\u0001\u0000\u0000\u0000\u151d"+ - "\u151f\u0001\u0000\u0000\u0000\u151e\u1520\u0005\u0301\u0000\u0000\u151f"+ - "\u151e\u0001\u0000\u0000\u0000\u151f\u1520\u0001\u0000\u0000\u0000\u1520"+ - "\u1522\u0001\u0000\u0000\u0000\u1521\u1512\u0001\u0000\u0000\u0000\u1522"+ - "\u1525\u0001\u0000\u0000\u0000\u1523\u1521\u0001\u0000\u0000\u0000\u1523"+ - "\u1524\u0001\u0000\u0000\u0000\u1524\u01f1\u0001\u0000\u0000\u0000\u1525"+ - "\u1523\u0001\u0000\u0000\u0000\u1526\u1528\u0005\u001b\u0000\u0000\u1527"+ - "\u1526\u0001\u0000\u0000\u0000\u1527\u1528\u0001\u0000\u0000\u0000\u1528"+ - "\u1529\u0001\u0000\u0000\u0000\u1529\u1532\u0003\u021a\u010d\u0000\u152a"+ - "\u152f\u0003\u021c\u010e\u0000\u152b\u152c\u0005\u02fa\u0000\u0000\u152c"+ - "\u152e\u0003\u021c\u010e\u0000\u152d\u152b\u0001\u0000\u0000\u0000\u152e"+ - "\u1531\u0001\u0000\u0000\u0000\u152f\u152d\u0001\u0000\u0000\u0000\u152f"+ - "\u1530\u0001\u0000\u0000\u0000\u1530\u1533\u0001\u0000\u0000\u0000\u1531"+ - "\u152f\u0001\u0000\u0000\u0000\u1532\u152a\u0001\u0000\u0000\u0000\u1532"+ - "\u1533\u0001\u0000\u0000\u0000\u1533\u153d\u0001\u0000\u0000\u0000\u1534"+ - "\u1536\u0005\u001b\u0000\u0000\u1535\u1534\u0001\u0000\u0000\u0000\u1535"+ - "\u1536\u0001\u0000\u0000\u0000\u1536\u1537\u0001\u0000\u0000\u0000\u1537"+ - "\u1538\u0003\u021a\u010d\u0000\u1538\u1539\u0005\u0300\u0000\u0000\u1539"+ - "\u153a\u0003\u01da\u00ed\u0000\u153a\u153b\u0005\u0301\u0000\u0000\u153b"+ - "\u153d\u0001\u0000\u0000\u0000\u153c\u1527\u0001\u0000\u0000\u0000\u153c"+ - "\u1535\u0001\u0000\u0000\u0000\u153d\u01f3\u0001\u0000\u0000\u0000\u153e"+ - "\u1540\u0005\u0112\u0000\u0000\u153f\u153e\u0001\u0000\u0000\u0000\u153f"+ - "\u1540\u0001\u0000\u0000\u0000\u1540\u1541\u0001\u0000\u0000\u0000\u1541"+ - "\u1554\u0005\u0124\u0000\u0000\u1542\u1544\u0005\u0131\u0000\u0000\u1543"+ - "\u1545\u0005\u018d\u0000\u0000\u1544\u1543\u0001\u0000\u0000\u0000\u1544"+ - "\u1545\u0001\u0000\u0000\u0000\u1545\u1546\u0001\u0000\u0000\u0000\u1546"+ - "\u1554\u0005\u0124\u0000\u0000\u1547\u1549\u0005\u01e4\u0000\u0000\u1548"+ - "\u154a\u0005\u018d\u0000\u0000\u1549\u1548\u0001\u0000\u0000\u0000\u1549"+ - "\u154a\u0001\u0000\u0000\u0000\u154a\u154b\u0001\u0000\u0000\u0000\u154b"+ - "\u1554\u0005\u0124\u0000\u0000\u154c\u154e\u0005\u00ed\u0000\u0000\u154d"+ - "\u154f\u0005\u018d\u0000\u0000\u154e\u154d\u0001\u0000\u0000\u0000\u154e"+ - "\u154f\u0001\u0000\u0000\u0000\u154f\u1550\u0001\u0000\u0000\u0000\u1550"+ - "\u1554\u0005\u0124\u0000\u0000\u1551\u1552\u0005\u0081\u0000\u0000\u1552"+ - "\u1554\u0005\u0124\u0000\u0000\u1553\u153f\u0001\u0000\u0000\u0000\u1553"+ - "\u1542\u0001\u0000\u0000\u0000\u1553\u1547\u0001\u0000\u0000\u0000\u1553"+ - "\u154c\u0001\u0000\u0000\u0000\u1553\u1551\u0001\u0000\u0000\u0000\u1554"+ - "\u01f5\u0001\u0000\u0000\u0000\u1555\u1556\u0005\u0180\u0000\u0000\u1556"+ - "\u1564\u0003\u01f8\u00fc\u0000\u1557\u1558\u0005\u0273\u0000\u0000\u1558"+ - "\u1559\u0005\u0300\u0000\u0000\u1559\u155e\u0003\u0218\u010c\u0000\u155a"+ - "\u155b\u0005\u02fa\u0000\u0000\u155b\u155d\u0003\u0218\u010c\u0000\u155c"+ - "\u155a\u0001\u0000\u0000\u0000\u155d\u1560\u0001\u0000\u0000\u0000\u155e"+ - "\u155c\u0001\u0000\u0000\u0000\u155e\u155f\u0001\u0000\u0000\u0000\u155f"+ - "\u1561\u0001\u0000\u0000\u0000\u1560\u155e\u0001\u0000\u0000\u0000\u1561"+ - "\u1562\u0005\u0301\u0000\u0000\u1562\u1564\u0001\u0000\u0000\u0000\u1563"+ - "\u1555\u0001\u0000\u0000\u0000\u1563\u1557\u0001\u0000\u0000\u0000\u1564"+ - "\u01f7\u0001\u0000\u0000\u0000\u1565\u1566\u0006\u00fc\uffff\uffff\u0000"+ - "\u1566\u1572\u0003\u01b8\u00dc\u0000\u1567\u1568\u0003\u01b8\u00dc\u0000"+ - "\u1568\u1569\u0003\u01d4\u00ea\u0000\u1569\u156a\u0003\u01b8\u00dc\u0000"+ - "\u156a\u1572\u0001\u0000\u0000\u0000\u156b\u156c\u0005\u0300\u0000\u0000"+ - "\u156c\u156d\u0003\u01f8\u00fc\u0000\u156d\u156e\u0005\u0301\u0000\u0000"+ - "\u156e\u1572\u0001\u0000\u0000\u0000\u156f\u1570\u0005\u016d\u0000\u0000"+ - "\u1570\u1572\u0003\u01f8\u00fc\u0001\u1571\u1565\u0001\u0000\u0000\u0000"+ - "\u1571\u1567\u0001\u0000\u0000\u0000\u1571\u156b\u0001\u0000\u0000\u0000"+ - "\u1571\u156f\u0001\u0000\u0000\u0000\u1572\u157b\u0001\u0000\u0000\u0000"+ - "\u1573\u1574\n\u0003\u0000\u0000\u1574\u1575\u0005\u0017\u0000\u0000\u1575"+ - "\u157a\u0003\u01f8\u00fc\u0004\u1576\u1577\n\u0002\u0000\u0000\u1577\u1578"+ - "\u0005\u0187\u0000\u0000\u1578\u157a\u0003\u01f8\u00fc\u0003\u1579\u1573"+ - "\u0001\u0000\u0000\u0000\u1579\u1576\u0001\u0000\u0000\u0000\u157a\u157d"+ - "\u0001\u0000\u0000\u0000\u157b\u1579\u0001\u0000\u0000\u0000\u157b\u157c"+ - "\u0001\u0000\u0000\u0000\u157c\u01f9\u0001\u0000\u0000\u0000\u157d\u157b"+ - "\u0001\u0000\u0000\u0000\u157e\u1599\u0005\u02ff\u0000\u0000\u157f\u1581"+ - "\u0007\u0006\u0000\u0000\u1580\u157f\u0001\u0000\u0000\u0000\u1580\u1581"+ - "\u0001\u0000\u0000\u0000\u1581\u1583\u0001\u0000\u0000\u0000\u1582\u1584"+ - "\u0003\u0210\u0108\u0000\u1583\u1582\u0001\u0000\u0000\u0000\u1583\u1584"+ - "\u0001\u0000\u0000\u0000\u1584\u1585\u0001\u0000\u0000\u0000\u1585\u1599"+ - "\u0003\u01e6\u00f3\u0000\u1586\u1588\u0007\u0006\u0000\u0000\u1587\u1586"+ - "\u0001\u0000\u0000\u0000\u1587\u1588\u0001\u0000\u0000\u0000\u1588\u158a"+ - "\u0001\u0000\u0000\u0000\u1589\u158b\u0003\u0210\u0108\u0000\u158a\u1589"+ - "\u0001\u0000\u0000\u0000\u158a\u158b\u0001\u0000\u0000\u0000\u158b\u158c"+ - "\u0001\u0000\u0000\u0000\u158c\u158d\u0003\u01e6\u00f3\u0000\u158d\u158e"+ - "\u0001\u0000\u0000\u0000\u158e\u158f\u0005\u0188\u0000\u0000\u158f\u1591"+ - "\u00056\u0000\u0000\u1590\u1592\u0007\u0006\u0000\u0000\u1591\u1590\u0001"+ - "\u0000\u0000\u0000\u1591\u1592\u0001\u0000\u0000\u0000\u1592\u1594\u0001"+ - "\u0000\u0000\u0000\u1593\u1595\u0003\u0210\u0108\u0000\u1594\u1593\u0001"+ - "\u0000\u0000\u0000\u1594\u1595\u0001\u0000\u0000\u0000\u1595\u1596\u0001"+ - "\u0000\u0000\u0000\u1596\u1597\u0003\u01e6\u00f3\u0000\u1597\u1599\u0001"+ - "\u0000\u0000\u0000\u1598\u157e\u0001\u0000\u0000\u0000\u1598\u1580\u0001"+ - "\u0000\u0000\u0000\u1598\u1587\u0001\u0000\u0000\u0000\u1599\u01fb\u0001"+ - "\u0000\u0000\u0000\u159a\u159b\u0005\u016d\u0000\u0000\u159b\u159c\u0005"+ - "\u0172\u0000\u0000\u159c\u01fd\u0001\u0000\u0000\u0000\u159d\u159f\u0003"+ - "\u01fc\u00fe\u0000\u159e\u159d\u0001\u0000\u0000\u0000\u159f\u15a0\u0001"+ - "\u0000\u0000\u0000\u15a0\u159e\u0001\u0000\u0000\u0000\u15a0\u15a1\u0001"+ - "\u0000\u0000\u0000\u15a1\u01ff\u0001\u0000\u0000\u0000\u15a2\u15a3\u0005"+ - "\u0288\u0000\u0000\u15a3\u15a4\u0005\u0300\u0000\u0000\u15a4\u15a5\u0003"+ - "\u01e0\u00f0\u0000\u15a5\u15a6\u0005\u0301\u0000\u0000\u15a6\u15a8\u0001"+ - "\u0000\u0000\u0000\u15a7\u15a2\u0001\u0000\u0000\u0000\u15a7\u15a8\u0001"+ - "\u0000\u0000\u0000\u15a8\u15ad\u0001\u0000\u0000\u0000\u15a9\u15aa\u0005"+ - "\u0273\u0000\u0000\u15aa\u15ab\u0005\u010c\u0000\u0000\u15ab\u15ac\u0005"+ - "\u023a\u0000\u0000\u15ac\u15ae\u0003\u0210\u0108\u0000\u15ad\u15a9\u0001"+ - "\u0000\u0000\u0000\u15ad\u15ae\u0001\u0000\u0000\u0000\u15ae\u0201\u0001"+ - "\u0000\u0000\u0000\u15af\u15b5\u0003\u0210\u0108\u0000\u15b0\u15b1\u0005"+ - "\u0300\u0000\u0000\u15b1\u15b2\u0003\u01b8\u00dc\u0000\u15b2\u15b3\u0005"+ - "\u0301\u0000\u0000\u15b3\u15b5\u0001\u0000\u0000\u0000\u15b4\u15af\u0001"+ - "\u0000\u0000\u0000\u15b4\u15b0\u0001\u0000\u0000\u0000\u15b5\u15b7\u0001"+ - "\u0000\u0000\u0000\u15b6\u15b8\u0003\u0210\u0108\u0000\u15b7\u15b6\u0001"+ - "\u0000\u0000\u0000\u15b7\u15b8\u0001\u0000\u0000\u0000\u15b8\u15ba\u0001"+ - "\u0000\u0000\u0000\u15b9\u15bb\u0007/\u0000\u0000\u15ba\u15b9\u0001\u0000"+ - "\u0000\u0000\u15ba\u15bb\u0001\u0000\u0000\u0000\u15bb\u15be\u0001\u0000"+ - "\u0000\u0000\u15bc\u15bd\u0005\u0175\u0000\u0000\u15bd\u15bf\u0007\u001f"+ - "\u0000\u0000\u15be\u15bc\u0001\u0000\u0000\u0000\u15be\u15bf\u0001\u0000"+ - "\u0000\u0000\u15bf\u0203\u0001\u0000\u0000\u0000\u15c0\u15c1\u0005m\u0000"+ - "\u0000\u15c1\u15c3\u0003\u01d8\u00ec\u0000\u15c2\u15c0\u0001\u0000\u0000"+ - "\u0000\u15c2\u15c3\u0001\u0000\u0000\u0000\u15c3\u1605\u0001\u0000\u0000"+ - "\u0000\u15c4\u15c5\u0005N\u0000\u0000\u15c5\u15c6\u0005\u0300\u0000\u0000"+ - "\u15c6\u15c7\u0003\u01b8\u00dc\u0000\u15c7\u15ca\u0005\u0301\u0000\u0000"+ - "\u15c8\u15c9\u0005\u0167\u0000\u0000\u15c9\u15cb\u0005\u0295\u0000\u0000"+ - "\u15ca\u15c8\u0001\u0000\u0000\u0000\u15ca\u15cb\u0001\u0000\u0000\u0000"+ - "\u15cb\u1606\u0001\u0000\u0000\u0000\u15cc\u15cd\u0005\u0264\u0000\u0000"+ - "\u15cd\u15ce\u0005\u0300\u0000\u0000\u15ce\u15cf\u0003\u01dc\u00ee\u0000"+ - "\u15cf\u15d0\u0005\u0301\u0000\u0000\u15d0\u1606\u0001\u0000\u0000\u0000"+ - "\u15d1\u15d2\u0005\u01b4\u0000\u0000\u15d2\u15d3\u0005\u0126\u0000\u0000"+ - "\u15d3\u15d4\u0005\u0300\u0000\u0000\u15d4\u15d5\u0003\u01dc\u00ee\u0000"+ - "\u15d5\u15d6\u0005\u0301\u0000\u0000\u15d6\u15d7\u0003\u0200\u0100\u0000"+ - "\u15d7\u1606\u0001\u0000\u0000\u0000\u15d8\u15db\u0005\u00cd\u0000\u0000"+ - "\u15d9\u15da\u0005\u0273\u0000\u0000\u15da\u15dc\u0003\u01e8\u00f4\u0000"+ - "\u15db\u15d9\u0001\u0000\u0000\u0000\u15db\u15dc\u0001\u0000\u0000\u0000"+ - "\u15dc\u15dd\u0001\u0000\u0000\u0000\u15dd\u15de\u0005\u0300\u0000\u0000"+ - "\u15de\u15df\u0003\u0202\u0101\u0000\u15df\u15e0\u0005\u0288\u0000\u0000"+ - "\u15e0\u15e1\u0003\u01dc\u00ee\u0000\u15e1\u15e2\u0005\u0301\u0000\u0000"+ - "\u15e2\u15e3\u0003\u0200\u0100\u0000\u15e3\u15e4\u0005\u0285\u0000\u0000"+ - "\u15e4\u15e5\u0005\u0300\u0000\u0000\u15e5\u15e6\u0003\u01f8\u00fc\u0000"+ - "\u15e6\u15e7\u0005\u0301\u0000\u0000\u15e7\u15e9\u0001\u0000\u0000\u0000"+ - "\u15e8\u15d8\u0001\u0000\u0000\u0000\u15e8\u15e9\u0001\u0000\u0000\u0000"+ - "\u15e9\u1606\u0001\u0000\u0000\u0000\u15ea\u15eb\u0005\u00e5\u0000\u0000"+ - "\u15eb\u15ec\u0005\u0126\u0000\u0000\u15ec\u15ed\u0005\u0300\u0000\u0000"+ - "\u15ed\u15ee\u0003\u01dc\u00ee\u0000\u15ee\u15ef\u0005\u0301\u0000\u0000"+ - "\u15ef\u15f0\u0005\u01c5\u0000\u0000\u15f0\u15f2\u0003\u0210\u0108\u0000"+ - "\u15f1\u15f3\u0003\u01dc\u00ee\u0000\u15f2\u15f1\u0001\u0000\u0000\u0000"+ - "\u15f2\u15f3\u0001\u0000\u0000\u0000\u15f3\u15f9\u0001\u0000\u0000\u0000"+ - "\u15f4\u15f5\u0005\u0146\u0000\u0000\u15f5\u15fa\u0005\u00ed\u0000\u0000"+ - "\u15f6\u15f7\u0005\u0146\u0000\u0000\u15f7\u15fa\u0005\u019e\u0000\u0000"+ - "\u15f8\u15fa\u0005\u0147\u0000\u0000\u15f9\u15f4\u0001\u0000\u0000\u0000"+ - "\u15f9\u15f6\u0001\u0000\u0000\u0000\u15f9\u15f8\u0001\u0000\u0000\u0000"+ - "\u15f9\u15fa\u0001\u0000\u0000\u0000\u15fa\u15fe\u0001\u0000\u0000\u0000"+ - "\u15fb\u15fc\u0005\u0180\u0000\u0000\u15fc\u15fd\u0005\u00a3\u0000\u0000"+ - "\u15fd\u15ff\u0003\u0210\u0108\u0000\u15fe\u15fb\u0001\u0000\u0000\u0000"+ - "\u15fe\u15ff\u0001\u0000\u0000\u0000\u15ff\u1603\u0001\u0000\u0000\u0000"+ - "\u1600\u1601\u0005\u0180\u0000\u0000\u1601\u1602\u0005\u026b\u0000\u0000"+ - "\u1602\u1604\u0003\u0210\u0108\u0000\u1603\u1600\u0001\u0000\u0000\u0000"+ - "\u1603\u1604\u0001\u0000\u0000\u0000\u1604\u1606\u0001\u0000\u0000\u0000"+ - "\u1605\u15c4\u0001\u0000\u0000\u0000\u1605\u15cc\u0001\u0000\u0000\u0000"+ - "\u1605\u15d1\u0001\u0000\u0000\u0000\u1605\u15e8\u0001\u0000\u0000\u0000"+ - "\u1605\u15ea\u0001\u0000\u0000\u0000\u1606\u160b\u0001\u0000\u0000\u0000"+ - "\u1607\u1609\u0005\u016d\u0000\u0000\u1608\u1607\u0001\u0000\u0000\u0000"+ - "\u1608\u1609\u0001\u0000\u0000\u0000\u1609\u160a\u0001\u0000\u0000\u0000"+ - "\u160a\u160c\u0005\u009d\u0000\u0000\u160b\u1608\u0001\u0000\u0000\u0000"+ - "\u160b\u160c\u0001\u0000\u0000\u0000\u160c\u160f\u0001\u0000\u0000\u0000"+ - "\u160d\u160e\u0005\u0111\u0000\u0000\u160e\u1610\u0007\u0016\u0000\u0000"+ - "\u160f\u160d\u0001\u0000\u0000\u0000\u160f\u1610\u0001\u0000\u0000\u0000"+ - "\u1610\u0205\u0001\u0000\u0000\u0000\u1611\u1616\u0003\u01d8\u00ec\u0000"+ - "\u1612\u1616\u0005\u008d\u0000\u0000\u1613\u1616\u0005\u0206\u0000\u0000"+ - "\u1614\u1616\u0005\u01b9\u0000\u0000\u1615\u1611\u0001\u0000\u0000\u0000"+ - "\u1615\u1612\u0001\u0000\u0000\u0000\u1615\u1613\u0001\u0000\u0000\u0000"+ - "\u1615\u1614\u0001\u0000\u0000\u0000\u1616\u0207\u0001\u0000\u0000\u0000"+ - "\u1617\u161c\u0003\u0206\u0103\u0000\u1618\u1619\u0005\u02fa\u0000\u0000"+ - "\u1619\u161b\u0003\u0206\u0103\u0000\u161a\u1618\u0001\u0000\u0000\u0000"+ - "\u161b\u161e\u0001\u0000\u0000\u0000\u161c\u161a\u0001\u0000\u0000\u0000"+ - "\u161c\u161d\u0001\u0000\u0000\u0000\u161d\u0209\u0001\u0000\u0000\u0000"+ - "\u161e\u161c\u0001\u0000\u0000\u0000\u161f\u162b\u0005\u0180\u0000\u0000"+ - "\u1620\u162b\u0005\u017c\u0000\u0000\u1621\u162b\u0005\u025a\u0000\u0000"+ - "\u1622\u162b\u0005\u00da\u0000\u0000\u1623\u162b\u0005\u028f\u0000\u0000"+ - "\u1624\u162b\u0005\u0167\u0000\u0000\u1625\u162b\u0005\u016a\u0000\u0000"+ - "\u1626\u162b\u0005\u030a\u0000\u0000\u1627\u162b\u0003\u01be\u00df\u0000"+ - "\u1628\u162b\u0003\u01bc\u00de\u0000\u1629\u162b\u0003\u0210\u0108\u0000"+ - "\u162a\u161f\u0001\u0000\u0000\u0000\u162a\u1620\u0001\u0000\u0000\u0000"+ - "\u162a\u1621\u0001\u0000\u0000\u0000\u162a\u1622\u0001\u0000\u0000\u0000"+ - "\u162a\u1623\u0001\u0000\u0000\u0000\u162a\u1624\u0001\u0000\u0000\u0000"+ - "\u162a\u1625\u0001\u0000\u0000\u0000\u162a\u1626\u0001\u0000\u0000\u0000"+ - "\u162a\u1627\u0001\u0000\u0000\u0000\u162a\u1628\u0001\u0000\u0000\u0000"+ - "\u162a\u1629\u0001\u0000\u0000\u0000\u162b\u020b\u0001\u0000\u0000\u0000"+ - "\u162c\u162d\u00070\u0000\u0000\u162d\u020d\u0001\u0000\u0000\u0000\u162e"+ - "\u162f\u00071\u0000\u0000\u162f\u020f\u0001\u0000\u0000\u0000\u1630\u1631"+ - "\u0006\u0108\uffff\uffff\u0000\u1631\u1637\u0003\u020e\u0107\u0000\u1632"+ - "\u1637\u0005\u030b\u0000\u0000\u1633\u1637\u0005\u030c\u0000\u0000\u1634"+ - "\u1637\u0003\u01d0\u00e8\u0000\u1635\u1637\u0005\u030e\u0000\u0000\u1636"+ - "\u1630\u0001\u0000\u0000\u0000\u1636\u1632\u0001\u0000\u0000\u0000\u1636"+ - "\u1633\u0001\u0000\u0000\u0000\u1636\u1634\u0001\u0000\u0000\u0000\u1636"+ - "\u1635\u0001\u0000\u0000\u0000\u1637\u163d\u0001\u0000\u0000\u0000\u1638"+ - "\u1639\n\u0003\u0000\u0000\u1639\u163a\u0005\u0309\u0000\u0000\u163a\u163c"+ - "\u0003\u0210\u0108\u0004\u163b\u1638\u0001\u0000\u0000\u0000\u163c\u163f"+ - "\u0001\u0000\u0000\u0000\u163d\u163b\u0001\u0000\u0000\u0000\u163d\u163e"+ - "\u0001\u0000\u0000\u0000\u163e\u0211\u0001\u0000\u0000\u0000\u163f\u163d"+ - "\u0001\u0000\u0000\u0000\u1640\u1641\t\u0000\u0000\u0000\u1641\u0213\u0001"+ - "\u0000\u0000\u0000\u1642\u1643\u0003\u0210\u0108\u0000\u1643\u0215\u0001"+ - "\u0000\u0000\u0000\u1644\u1645\u0003\u0210\u0108\u0000\u1645\u0217\u0001"+ - "\u0000\u0000\u0000\u1646\u1647\u0003\u0210\u0108\u0000\u1647\u0219\u0001"+ - "\u0000\u0000\u0000\u1648\u1649\u0003\u0210\u0108\u0000\u1649\u021b\u0001"+ - "\u0000\u0000\u0000\u164a\u164b\u0003\u0210\u0108\u0000\u164b\u021d\u0001"+ - "\u0000\u0000\u0000\u164c\u164d\u0003\u0210\u0108\u0000\u164d\u021f\u0001"+ - "\u0000\u0000\u0000\u164e\u164f\u0003\u0210\u0108\u0000\u164f\u0221\u0001"+ - "\u0000\u0000\u0000\u02be\u0227\u022b\u0263\u028f\u02af\u02cc\u02e3\u02f1"+ - "\u0301\u030a\u030e\u0335\u0343\u034e\u0358\u0360\u0369\u036f\u0375\u0378"+ - "\u037c\u0380\u0384\u0388\u038d\u0393\u0397\u03a0\u03a8\u03b1\u03ba\u03c4"+ - "\u03ce\u03d7\u03dc\u03e2\u03eb\u03ef\u03f6\u03fd\u0417\u0419\u0420\u0428"+ - "\u042b\u042f\u0438\u043b\u043f\u0443\u044e\u045a\u0461\u047a\u0480\u048b"+ - "\u049e\u04aa\u04ba\u04c0\u04c2\u04c6\u04d0\u04d9\u04db\u04e6\u0501\u050d"+ - "\u0521\u0525\u052a\u052c\u0534\u053e\u0548\u0562\u0576\u057d\u0583\u0588"+ - "\u0595\u059a\u05a1\u05a7\u05ac\u05b7\u05bc\u05c4\u05c9\u05cd\u05e7\u05e9"+ - "\u05ef\u05f4\u05f8\u05fc\u0600\u0604\u060e\u0615\u0625\u062f\u063f\u0652"+ - "\u065e\u0680\u0690\u06a3\u06b5\u06f2\u0712\u072a\u073f\u0755\u075c\u0791"+ - "\u07a1\u07a4\u07b4\u07ba\u07be\u07c4\u07ca\u07d0\u07d6\u07dc\u07e2\u07e8"+ - "\u07ee\u07f4\u07f8\u07fe\u0804\u080a\u0813\u0816\u0819\u081e\u0821\u0831"+ - "\u0837\u083b\u0841\u0847\u084b\u0862\u0868\u086c\u0872\u0878\u087e\u0884"+ - "\u088a\u0890\u0896\u089c\u08a2\u08a6\u08ac\u08b2\u08b6\u08c6\u08cc\u08d2"+ - "\u08e6\u08ed\u08f5\u0901\u0907\u090b\u091a\u091f\u0924\u0929\u092e\u0933"+ - "\u0938\u093d\u0943\u0948\u094c\u0956\u095c\u0964\u0966\u0971\u0979\u0984"+ - "\u0992\u099e\u09a0\u09a7\u09ae\u09b6\u09c1\u09c5\u09ca\u09d3\u09d8\u09e1"+ - "\u09f0\u0a05\u0a07\u0a09\u0a0d\u0a11\u0a16\u0a19\u0a1f\u0a23\u0a27\u0a2c"+ - "\u0a2f\u0a36\u0a39\u0a3c\u0a44\u0a48\u0a4a\u0a52\u0a59\u0a5c\u0a60\u0a66"+ - "\u0a69\u0a76\u0a7c\u0a82\u0a88\u0a8e\u0a94\u0a98\u0a9c\u0aa9\u0ab1\u0ab5"+ - "\u0abe\u0ac5\u0ace\u0ad6\u0ae7\u0aeb\u0af2\u0afa\u0b00\u0b14\u0b29\u0b2b"+ - "\u0b2d\u0b34\u0b3f\u0b43\u0b47\u0b4e\u0b51\u0b58\u0b62\u0b6b\u0b6f\u0b75"+ - "\u0b7a\u0b7d\u0b83\u0b89\u0b8d\u0b90\u0b94\u0b97\u0b9a\u0ba3\u0ba5\u0bc8"+ - "\u0bcb\u0bce\u0bd6\u0bdd\u0be2\u0be6\u0bea\u0bf1\u0bf6\u0bfa\u0bfd\u0c00"+ - "\u0c04\u0c0b\u0c0e\u0c3c\u0c43\u0c47\u0c4d\u0c58\u0c60\u0c66\u0c6a\u0c70"+ - "\u0c74\u0c7a\u0c82\u0c86\u0c8d\u0c91\u0c97\u0c9b\u0ca3\u0ca7\u0cae\u0cb2"+ - "\u0cb8\u0cbc\u0cc2\u0cc9\u0ccd\u0cd1\u0cd5\u0cda\u0cde\u0ce5\u0ce9\u0cf2"+ - "\u0cf8\u0cff\u0d05\u0d0c\u0d12\u0d18\u0d1e\u0d22\u0d28\u0d30\u0d36\u0d3c"+ - "\u0d40\u0d46\u0d4a\u0d50\u0d54\u0d5a\u0d62\u0d66\u0d6c\u0d70\u0d76\u0d80"+ - "\u0d84\u0d8c\u0d90\u0d98\u0d9c\u0da4\u0da8\u0dae\u0dba\u0dc0\u0dc6\u0dca"+ - "\u0dd0\u0dd9\u0de1\u0dea\u0dee\u0df3\u0df7\u0dfa\u0e03\u0e08\u0e13\u0e1c"+ - "\u0e23\u0e29\u0e2d\u0e30\u0e36\u0e3e\u0e43\u0e46\u0e4f\u0e51\u0e53\u0e56"+ - "\u0e5f\u0e62\u0e66\u0e79\u0e7c\u0e7f\u0e8f\u0e94\u0e96\u0e99\u0e9b\u0ea3"+ - "\u0eab\u0eb3\u0ebf\u0ec5\u0ec9\u0ed0\u0ed8\u0edf\u0ee6\u0eec\u0ef4\u0ef8"+ - "\u0f03\u0f28\u0f3c\u0f42\u0f47\u0f4b\u0f4f\u0f54\u0f5a\u0f5e\u0f61\u0f64"+ - "\u0f67\u0f6a\u0f6d\u0f70\u0f73\u0f76\u0f79\u0f7c\u0f7f\u0f85\u0f88\u0f8c"+ - "\u0f90\u0f94\u0f99\u0f9f\u0fa3\u0fa6\u0fa9\u0fac\u0faf\u0fb2\u0fb5\u0fb8"+ - "\u0fbb\u0fbe\u0fc1\u0fc5\u0fcc\u0fd4\u0fdd\u0fe3\u0fe9\u0fed\u0ff4\u0ff6"+ - "\u0ffc\u1002\u1007\u100b\u1018\u101f\u1022\u1029\u1039\u1040\u1044\u1047"+ - "\u104b\u104f\u1052\u1056\u1059\u105e\u1061\u1065\u1069\u106c\u106f\u1074"+ - "\u107b\u107e\u1087\u108f\u1096\u109a\u109d\u10a0\u10a3\u10a7\u10aa\u10ad"+ - "\u10b5\u10b7\u10b9\u10bc\u10c3\u10c9\u10cd\u10d0\u10d3\u10d6\u10d9\u10dc"+ - "\u10e2\u10e6\u10f0\u10fd\u1108\u110d\u1111\u1119\u1121\u112c\u1131\u1134"+ - "\u1137\u113c\u113f\u1142\u1146\u114b\u114f\u115d\u116b\u1172\u117e\u1181"+ - "\u1184\u1187\u1192\u1198\u119c\u11a1\u11a6\u11ab\u11af\u11b8\u11bd\u11c3"+ - "\u11cd\u11d0\u11d6\u11db\u11e0\u11ed\u11f5\u11f8\u11fd\u11ff\u1207\u1211"+ - "\u1213\u122a\u1232\u124a\u1266\u1278\u127d\u1288\u1291\u12a3\u12a8\u12ac"+ - "\u12b1\u12b8\u12c5\u12cd\u12cf\u12de\u12e0\u12e4\u12e8\u12ef\u12f7\u12f9"+ - "\u1305\u1309\u1315\u1319\u131d\u1325\u132b\u1332\u1336\u1339\u133c\u133f"+ - "\u1346\u134e\u1355\u1360\u1366\u1370\u1376\u137c\u1387\u1395\u1398\u13a7"+ - "\u13b9\u13be\u13c4\u13c9\u13cf\u13d5\u13df\u13e5\u13e8\u13f0\u13f5\u13fc"+ - "\u1400\u1409\u1415\u141e\u1421\u142f\u1431\u1435\u143c\u1444\u144a\u1451"+ - "\u1458\u145c\u1461\u1469\u146e\u147f\u1485\u1487\u1492\u1496\u149f\u14a2"+ - "\u14a8\u14ac\u14af\u14b9\u14c2\u14c4\u14c7\u14cd\u14d6\u14db\u14de\u14e3"+ - "\u14e6\u14e9\u14f3\u14f9\u1507\u150c\u1510\u1514\u1518\u151c\u151f\u1523"+ - "\u1527\u152f\u1532\u1535\u153c\u153f\u1544\u1549\u154e\u1553\u155e\u1563"+ - "\u1571\u1579\u157b\u1580\u1583\u1587\u158a\u1591\u1594\u1598\u15a0\u15a7"+ - "\u15ad\u15b4\u15b7\u15ba\u15be\u15c2\u15ca\u15db\u15e8\u15f2\u15f9\u15fe"+ - "\u1603\u1605\u1608\u160b\u160f\u1615\u161c\u162a\u1636\u163d"; + "\u008c\u0000\u0000\u0e62\u0e63\u0005\u0146\u0000\u0000\u0e63\u0e69\u0003"+ + "\u053c\u029e\u0000\u0e64\u0e6a\u0003\u0158\u00ac\u0000\u0e65\u0e67\u0003"+ + "\u0168\u00b4\u0000\u0e66\u0e68\u0003\u0158\u00ac\u0000\u0e67\u0e66\u0001"+ + "\u0000\u0000\u0000\u0e67\u0e68\u0001\u0000\u0000\u0000\u0e68\u0e6a\u0001"+ + "\u0000\u0000\u0000\u0e69\u0e64\u0001\u0000\u0000\u0000\u0e69\u0e65\u0001"+ + "\u0000\u0000\u0000\u0e6a\u016d\u0001\u0000\u0000\u0000\u0e6b\u0e6c\u0005"+ + "0\u0000\u0000\u0e6c\u0e6d\u0005A\u0000\u0000\u0e6d\u0e6e\u0005^\u0000"+ + "\u0000\u0e6e\u0e6f\u0003\u0538\u029c\u0000\u0e6f\u0e70\u0005\u0003\u0000"+ + "\u0000\u0e70\u0e71\u0003\u00b0X\u0000\u0e71\u0e72\u0005\u0004\u0000\u0000"+ + "\u0e72\u0e73\u0003\u00eew\u0000\u0e73\u0e74\u0005\u0146\u0000\u0000\u0e74"+ + "\u0e75\u0003\u053c\u029e\u0000\u0e75\u0e76\u0003\u0154\u00aa\u0000\u0e76"+ + "\u0ea4\u0001\u0000\u0000\u0000\u0e77\u0e78\u00050\u0000\u0000\u0e78\u0e79"+ + "\u0005A\u0000\u0000\u0e79\u0e7a\u0005^\u0000\u0000\u0e7a\u0e7b\u0005\u00de"+ + "\u0000\u0000\u0e7b\u0e7c\u0005O\u0000\u0000\u0e7c\u0e7d\u0005\u0187\u0000"+ + "\u0000\u0e7d\u0e7e\u0003\u0538\u029c\u0000\u0e7e\u0e7f\u0005\u0003\u0000"+ + "\u0000\u0e7f\u0e80\u0003\u00b0X\u0000\u0e80\u0e81\u0005\u0004\u0000\u0000"+ + "\u0e81\u0e82\u0003\u00eew\u0000\u0e82\u0e83\u0005\u0146\u0000\u0000\u0e83"+ + "\u0e84\u0003\u053c\u029e\u0000\u0e84\u0e85\u0003\u0154\u00aa\u0000\u0e85"+ + "\u0ea4\u0001\u0000\u0000\u0000\u0e86\u0e87\u00050\u0000\u0000\u0e87\u0e88"+ + "\u0005A\u0000\u0000\u0e88\u0e89\u0005^\u0000\u0000\u0e89\u0e8a\u0003\u0538"+ + "\u029c\u0000\u0e8a\u0e8b\u0005\u0118\u0000\u0000\u0e8b\u0e8c\u0005\u010e"+ + "\u0000\u0000\u0e8c\u0e8d\u0003\u0538\u029c\u0000\u0e8d\u0e8e\u0003\u00b2"+ + "Y\u0000\u0e8e\u0e8f\u0003\u0080@\u0000\u0e8f\u0e90\u0005\u0146\u0000\u0000"+ + "\u0e90\u0e91\u0003\u053c\u029e\u0000\u0e91\u0e92\u0003\u0154\u00aa\u0000"+ + "\u0e92\u0ea4\u0001\u0000\u0000\u0000\u0e93\u0e94\u00050\u0000\u0000\u0e94"+ + "\u0e95\u0005A\u0000\u0000\u0e95\u0e96\u0005^\u0000\u0000\u0e96\u0e97\u0005"+ + "\u00de\u0000\u0000\u0e97\u0e98\u0005O\u0000\u0000\u0e98\u0e99\u0005\u0187"+ + "\u0000\u0000\u0e99\u0e9a\u0003\u0538\u029c\u0000\u0e9a\u0e9b\u0005\u0118"+ + "\u0000\u0000\u0e9b\u0e9c\u0005\u010e\u0000\u0000\u0e9c\u0e9d\u0003\u0538"+ + "\u029c\u0000\u0e9d\u0e9e\u0003\u00b2Y\u0000\u0e9e\u0e9f\u0003\u0080@\u0000"+ + "\u0e9f\u0ea0\u0005\u0146\u0000\u0000\u0ea0\u0ea1\u0003\u053c\u029e\u0000"+ + "\u0ea1\u0ea2\u0003\u0154\u00aa\u0000\u0ea2\u0ea4\u0001\u0000\u0000\u0000"+ + "\u0ea3\u0e6b\u0001\u0000\u0000\u0000\u0ea3\u0e77\u0001\u0000\u0000\u0000"+ + "\u0ea3\u0e86\u0001\u0000\u0000\u0000\u0ea3\u0e93\u0001\u0000\u0000\u0000"+ + "\u0ea4\u016f\u0001\u0000\u0000\u0000\u0ea5\u0ea6\u0005\u01be\u0000\u0000"+ + "\u0ea6\u0ea7\u0005A\u0000\u0000\u0ea7\u0ea8\u0005\u013e\u0000\u0000\u0ea8"+ + "\u0ea9\u0003\u053c\u029e\u0000\u0ea9\u0eaa\u0003\u0174\u00ba\u0000\u0eaa"+ + "\u0eab\u0005B\u0000\u0000\u0eab\u0eac\u0005\u0146\u0000\u0000\u0eac\u0ead"+ + "\u0003\u053c\u029e\u0000\u0ead\u0eae\u0005I\u0000\u0000\u0eae\u0eaf\u0003"+ + "\u053c\u029e\u0000\u0eaf\u0eb0\u0003\u0154\u00aa\u0000\u0eb0\u0171\u0001"+ + "\u0000\u0000\u0000\u0eb1\u0eb2\u0005L\u0000\u0000\u0eb2\u0eb5\u0005`\u0000"+ + "\u0000\u0eb3\u0eb5\u0005=\u0000\u0000\u0eb4\u0eb1\u0001\u0000\u0000\u0000"+ + "\u0eb4\u0eb3\u0001\u0000\u0000\u0000\u0eb5\u0173\u0001\u0000\u0000\u0000"+ + "\u0eb6\u0eb7\u0003\u0172\u00b9\u0000\u0eb7\u0eb8\u0005\u0003\u0000\u0000"+ + "\u0eb8\u0eb9\u0003\u0436\u021b\u0000\u0eb9\u0eba\u0005\u0004\u0000\u0000"+ + "\u0eba\u0ebd\u0001\u0000\u0000\u0000\u0ebb\u0ebd\u0001\u0000\u0000\u0000"+ + "\u0ebc\u0eb6\u0001\u0000\u0000\u0000\u0ebc\u0ebb\u0001\u0000\u0000\u0000"+ + "\u0ebd\u0175\u0001\u0000\u0000\u0000\u0ebe\u0ebf\u00050\u0000\u0000\u0ebf"+ + "\u0ec0\u0005e\u0000\u0000\u0ec0\u0ec1\u0005\u00fa\u0000\u0000\u0ec1\u0ec2"+ + "\u0005@\u0000\u0000\u0ec2\u0ec3\u0003\u0178\u00bc\u0000\u0ec3\u0ec4\u0005"+ + "\u0146\u0000\u0000\u0ec4\u0ec5\u0003\u053c\u029e\u0000\u0ec5\u0ec6\u0003"+ + "\u0154\u00aa\u0000\u0ec6\u0ed4\u0001\u0000\u0000\u0000\u0ec7\u0ec8\u0005"+ + "0\u0000\u0000\u0ec8\u0ec9\u0005e\u0000\u0000\u0ec9\u0eca\u0005\u00fa\u0000"+ + "\u0000\u0eca\u0ecb\u0005\u00de\u0000\u0000\u0ecb\u0ecc\u0005O\u0000\u0000"+ + "\u0ecc\u0ecd\u0005\u0187\u0000\u0000\u0ecd\u0ece\u0005@\u0000\u0000\u0ece"+ + "\u0ecf\u0003\u0178\u00bc\u0000\u0ecf\u0ed0\u0005\u0146\u0000\u0000\u0ed0"+ + "\u0ed1\u0003\u053c\u029e\u0000\u0ed1\u0ed2\u0003\u0154\u00aa\u0000\u0ed2"+ + "\u0ed4\u0001\u0000\u0000\u0000\u0ed3\u0ebe\u0001\u0000\u0000\u0000\u0ed3"+ + "\u0ec7\u0001\u0000\u0000\u0000\u0ed4\u0177\u0001\u0000\u0000\u0000\u0ed5"+ + "\u0ed8\u0003\u0558\u02ac\u0000\u0ed6\u0ed8\u0005e\u0000\u0000\u0ed7\u0ed5"+ + "\u0001\u0000\u0000\u0000\u0ed7\u0ed6\u0001\u0000\u0000\u0000\u0ed8\u0179"+ + "\u0001\u0000\u0000\u0000\u0ed9\u0eda\u0005\u00c1\u0000\u0000\u0eda\u0edb"+ + "\u0005e\u0000\u0000\u0edb\u0edc\u0005\u00fa\u0000\u0000\u0edc\u0edd\u0005"+ + "@\u0000\u0000\u0edd\u0ede\u0003\u0178\u00bc\u0000\u0ede\u0edf\u0005\u0146"+ + "\u0000\u0000\u0edf\u0ee0\u0003\u053c\u029e\u0000\u0ee0\u0eec\u0001\u0000"+ + "\u0000\u0000\u0ee1\u0ee2\u0005\u00c1\u0000\u0000\u0ee2\u0ee3\u0005e\u0000"+ + "\u0000\u0ee3\u0ee4\u0005\u00fa\u0000\u0000\u0ee4\u0ee5\u0005\u00de\u0000"+ + "\u0000\u0ee5\u0ee6\u0005\u0187\u0000\u0000\u0ee6\u0ee7\u0005@\u0000\u0000"+ + "\u0ee7\u0ee8\u0003\u0178\u00bc\u0000\u0ee8\u0ee9\u0005\u0146\u0000\u0000"+ + "\u0ee9\u0eea\u0003\u053c\u029e\u0000\u0eea\u0eec\u0001\u0000\u0000\u0000"+ + "\u0eeb\u0ed9\u0001\u0000\u0000\u0000\u0eeb\u0ee1\u0001\u0000\u0000\u0000"+ + "\u0eec\u017b\u0001\u0000\u0000\u0000\u0eed\u0eee\u0005\u008c\u0000\u0000"+ + "\u0eee\u0eef\u0005e\u0000\u0000\u0eef\u0ef0\u0005\u00fa\u0000\u0000\u0ef0"+ + "\u0ef1\u0005@\u0000\u0000\u0ef1\u0ef2\u0003\u0178\u00bc\u0000\u0ef2\u0ef3"+ + "\u0005\u0146\u0000\u0000\u0ef3\u0ef4\u0003\u053c\u029e\u0000\u0ef4\u0ef5"+ + "\u0003\u0158\u00ac\u0000\u0ef5\u017d\u0001\u0000\u0000\u0000\u0ef6\u0ef7"+ + "\u00050\u0000\u0000\u0ef7\u0ef8\u0005\u01bf\u0000\u0000\u0ef8\u0ef9\u0003"+ + "\u053c\u029e\u0000\u0ef9\u0efa\u0005R\u0000\u0000\u0efa\u0efb\u0003\u0538"+ + "\u029c\u0000\u0efb\u0efc\u0003\u018a\u00c5\u0000\u0efc\u0efd\u0003\u018c"+ + "\u00c6\u0000\u0efd\u0efe\u0003\u0186\u00c3\u0000\u0efe\u0eff\u0003\u0182"+ + "\u00c1\u0000\u0eff\u0f00\u0003\u0184\u00c2\u0000\u0f00\u017f\u0001\u0000"+ + "\u0000\u0000\u0f01\u0f02\u0005\u008c\u0000\u0000\u0f02\u0f03\u0005\u01bf"+ + "\u0000\u0000\u0f03\u0f04\u0003\u053c\u029e\u0000\u0f04\u0f05\u0005R\u0000"+ + "\u0000\u0f05\u0f06\u0003\u0538\u029c\u0000\u0f06\u0f07\u0003\u0188\u00c4"+ + "\u0000\u0f07\u0f08\u0003\u0182\u00c1\u0000\u0f08\u0f09\u0003\u0184\u00c2"+ + "\u0000\u0f09\u0181\u0001\u0000\u0000\u0000\u0f0a\u0f0b\u0005f\u0000\u0000"+ + "\u0f0b\u0f0c\u0005\u0003\u0000\u0000\u0f0c\u0f0d\u0003\u048c\u0246\u0000"+ + "\u0f0d\u0f0e\u0005\u0004\u0000\u0000\u0f0e\u0f11\u0001\u0000\u0000\u0000"+ + "\u0f0f\u0f11\u0001\u0000\u0000\u0000\u0f10\u0f0a\u0001\u0000\u0000\u0000"+ + "\u0f10\u0f0f\u0001\u0000\u0000\u0000\u0f11\u0183\u0001\u0000\u0000\u0000"+ + "\u0f12\u0f13\u0005k\u0000\u0000\u0f13\u0f14\u0005,\u0000\u0000\u0f14\u0f15"+ + "\u0005\u0003\u0000\u0000\u0f15\u0f16\u0003\u048c\u0246\u0000\u0f16\u0f17"+ + "\u0005\u0004\u0000\u0000\u0f17\u0f1a\u0001\u0000\u0000\u0000\u0f18\u0f1a"+ + "\u0001\u0000\u0000\u0000\u0f19\u0f12\u0001\u0000\u0000\u0000\u0f19\u0f18"+ + "\u0001\u0000\u0000\u0000\u0f1a\u0185\u0001\u0000\u0000\u0000\u0f1b\u0f1c"+ + "\u0005`\u0000\u0000\u0f1c\u0f1f\u0003\u055a\u02ad\u0000\u0f1d\u0f1f\u0001"+ + "\u0000\u0000\u0000\u0f1e\u0f1b\u0001\u0000\u0000\u0000\u0f1e\u0f1d\u0001"+ + "\u0000\u0000\u0000\u0f1f\u0187\u0001\u0000\u0000\u0000\u0f20\u0f21\u0005"+ + "`\u0000\u0000\u0f21\u0f24\u0003\u055a\u02ad\u0000\u0f22\u0f24\u0001\u0000"+ + "\u0000\u0000\u0f23\u0f20\u0001\u0000\u0000\u0000\u0f23\u0f22\u0001\u0000"+ + "\u0000\u0000\u0f24\u0189\u0001\u0000\u0000\u0000\u0f25\u0f26\u0005&\u0000"+ + "\u0000\u0f26\u0f29\u0003\u0566\u02b3\u0000\u0f27\u0f29\u0001\u0000\u0000"+ + "\u0000\u0f28\u0f25\u0001\u0000\u0000\u0000\u0f28\u0f27\u0001\u0000\u0000"+ + "\u0000\u0f29\u018b\u0001\u0000\u0000\u0000\u0f2a\u0f2b\u0005@\u0000\u0000"+ + "\u0f2b\u0f2e\u0003\u018e\u00c7\u0000\u0f2c\u0f2e\u0001\u0000\u0000\u0000"+ + "\u0f2d\u0f2a\u0001\u0000\u0000\u0000\u0f2d\u0f2c\u0001\u0000\u0000\u0000"+ + "\u0f2e\u018d\u0001\u0000\u0000\u0000\u0f2f\u0f30\u0007\u0011\u0000\u0000"+ + "\u0f30\u018f\u0001\u0000\u0000\u0000\u0f31\u0f32\u00050\u0000\u0000\u0f32"+ + "\u0f33\u0005\u0085\u0000\u0000\u0f33\u0f34\u0005\u01c0\u0000\u0000\u0f34"+ + "\u0f35\u0003\u053c\u029e\u0000\u0f35\u0f36\u0005\u0163\u0000\u0000\u0f36"+ + "\u0f37\u0003\u0192\u00c9\u0000\u0f37\u0f38\u0005\u00d9\u0000\u0000\u0f38"+ + "\u0f39\u0003\u012c\u0096\u0000\u0f39\u0191\u0001\u0000\u0000\u0000\u0f3a"+ + "\u0f3b\u0007\u0012\u0000\u0000\u0f3b\u0193\u0001\u0000\u0000\u0000\u0f3c"+ + "\u0f3d\u00050\u0000\u0000\u0f3d\u0f3e\u0005\u0160\u0000\u0000\u0f3e\u0f3f"+ + "\u0003\u053c\u029e\u0000\u0f3f\u0f40\u0003\u0196\u00cb\u0000\u0f40\u0f41"+ + "\u0003\u0198\u00cc\u0000\u0f41\u0f42\u0005R\u0000\u0000\u0f42\u0f43\u0003"+ + "\u0538\u029c\u0000\u0f43\u0f44\u0003\u019c\u00ce\u0000\u0f44\u0f45\u0003"+ + "\u01a8\u00d4\u0000\u0f45\u0f46\u0003\u01ae\u00d7\u0000\u0f46\u0f47\u0005"+ + "\u00cc\u0000\u0000\u0f47\u0f48\u0003\u01b0\u00d8\u0000\u0f48\u0f49\u0003"+ + "\u0542\u02a1\u0000\u0f49\u0f4a\u0005\u0003\u0000\u0000\u0f4a\u0f4b\u0003"+ + "\u01b2\u00d9\u0000\u0f4b\u0f4c\u0005\u0004\u0000\u0000\u0f4c\u0f63\u0001"+ + "\u0000\u0000\u0000\u0f4d\u0f4e\u00050\u0000\u0000\u0f4e\u0f4f\u0005/\u0000"+ + "\u0000\u0f4f\u0f50\u0005\u0160\u0000\u0000\u0f50\u0f51\u0003\u053c\u029e"+ + "\u0000\u0f51\u0f52\u0005\u0089\u0000\u0000\u0f52\u0f53\u0003\u0198\u00cc"+ + "\u0000\u0f53\u0f54\u0005R\u0000\u0000\u0f54\u0f55\u0003\u0538\u029c\u0000"+ + "\u0f55\u0f56\u0003\u01b6\u00db\u0000\u0f56\u0f57\u0003\u01b8\u00dc\u0000"+ + "\u0f57\u0f58\u0005@\u0000\u0000\u0f58\u0f59\u0005\u00c2\u0000\u0000\u0f59"+ + "\u0f5a\u0005\u0199\u0000\u0000\u0f5a\u0f5b\u0003\u01ae\u00d7\u0000\u0f5b"+ + "\u0f5c\u0005\u00cc\u0000\u0000\u0f5c\u0f5d\u0003\u01b0\u00d8\u0000\u0f5d"+ + "\u0f5e\u0003\u0542\u02a1\u0000\u0f5e\u0f5f\u0005\u0003\u0000\u0000\u0f5f"+ + "\u0f60\u0003\u01b2\u00d9\u0000\u0f60\u0f61\u0005\u0004\u0000\u0000\u0f61"+ + "\u0f63\u0001\u0000\u0000\u0000\u0f62\u0f3c\u0001\u0000\u0000\u0000\u0f62"+ + "\u0f4d\u0001\u0000\u0000\u0000\u0f63\u0195\u0001\u0000\u0000\u0000\u0f64"+ + "\u0f69\u0005\u0093\u0000\u0000\u0f65\u0f69\u0005\u0089\u0000\u0000\u0f66"+ + "\u0f67\u0005\u00eb\u0000\u0000\u0f67\u0f69\u0005\u010e\u0000\u0000\u0f68"+ + "\u0f64\u0001\u0000\u0000\u0000\u0f68\u0f65\u0001\u0000\u0000\u0000\u0f68"+ + "\u0f66\u0001\u0000\u0000\u0000\u0f69\u0197\u0001\u0000\u0000\u0000\u0f6a"+ + "\u0f6f\u0003\u019a\u00cd\u0000\u0f6b\u0f6c\u0005T\u0000\u0000\u0f6c\u0f6e"+ + "\u0003\u019a\u00cd\u0000\u0f6d\u0f6b\u0001\u0000\u0000\u0000\u0f6e\u0f71"+ + "\u0001\u0000\u0000\u0000\u0f6f\u0f6d\u0001\u0000\u0000\u0000\u0f6f\u0f70"+ + "\u0001\u0000\u0000\u0000\u0f70\u0199\u0001\u0000\u0000\u0000\u0f71\u0f6f"+ + "\u0001\u0000\u0000\u0000\u0f72\u0f7a\u0005\u00ea\u0000\u0000\u0f73\u0f7a"+ + "\u0005\u00b8\u0000\u0000\u0f74\u0f7a\u0005\u016c\u0000\u0000\u0f75\u0f76"+ + "\u0005\u016c\u0000\u0000\u0f76\u0f77\u0005\u010e\u0000\u0000\u0f77\u0f7a"+ + "\u0003\u00d8l\u0000\u0f78\u0f7a\u0005\u0161\u0000\u0000\u0f79\u0f72\u0001"+ + "\u0000\u0000\u0000\u0f79\u0f73\u0001\u0000\u0000\u0000\u0f79\u0f74\u0001"+ + "\u0000\u0000\u0000\u0f79\u0f75\u0001\u0000\u0000\u0000\u0f79\u0f78\u0001"+ + "\u0000\u0000\u0000\u0f7a\u019b\u0001\u0000\u0000\u0000\u0f7b\u0f7c\u0005"+ + "\u01c1\u0000\u0000\u0f7c\u0f7f\u0003\u019e\u00cf\u0000\u0f7d\u0f7f\u0001"+ + "\u0000\u0000\u0000\u0f7e\u0f7b\u0001\u0000\u0000\u0000\u0f7e\u0f7d\u0001"+ + "\u0000\u0000\u0000\u0f7f\u019d\u0001\u0000\u0000\u0000\u0f80\u0f82\u0003"+ + "\u01a0\u00d0\u0000\u0f81\u0f80\u0001\u0000\u0000\u0000\u0f82\u0f83\u0001"+ + "\u0000\u0000\u0000\u0f83\u0f81\u0001\u0000\u0000\u0000\u0f83\u0f84\u0001"+ + "\u0000\u0000\u0000\u0f84\u019f\u0001\u0000\u0000\u0000\u0f85\u0f86\u0003"+ + "\u01a2\u00d1\u0000\u0f86\u0f87\u0003\u01a4\u00d2\u0000\u0f87\u0f88\u0003"+ + "\u0342\u01a1\u0000\u0f88\u0f89\u0003\u01a6\u00d3\u0000\u0f89\u01a1\u0001"+ + "\u0000\u0000\u0000\u0f8a\u0f8b\u0007\u0013\u0000\u0000\u0f8b\u01a3\u0001"+ + "\u0000\u0000\u0000\u0f8c\u0f8d\u0007\u0014\u0000\u0000\u0f8d\u01a5\u0001"+ + "\u0000\u0000\u0000\u0f8e\u0f8f\u0003\u055c\u02ae\u0000\u0f8f\u01a7\u0001"+ + "\u0000\u0000\u0000\u0f90\u0f91\u0005@\u0000\u0000\u0f91\u0f92\u0003\u01aa"+ + "\u00d5\u0000\u0f92\u0f93\u0003\u01ac\u00d6\u0000\u0f93\u0f96\u0001\u0000"+ + "\u0000\u0000\u0f94\u0f96\u0001\u0000\u0000\u0000\u0f95\u0f90\u0001\u0000"+ + "\u0000\u0000\u0f95\u0f94\u0001\u0000\u0000\u0000\u0f96\u01a9\u0001\u0000"+ + "\u0000\u0000\u0f97\u0f9a\u0005\u00c2\u0000\u0000\u0f98\u0f9a\u0001\u0000"+ + "\u0000\u0000\u0f99\u0f97\u0001\u0000\u0000\u0000\u0f99\u0f98\u0001\u0000"+ + "\u0000\u0000\u0f9a\u01ab\u0001\u0000\u0000\u0000\u0f9b\u0f9c\u0007\u0015"+ + "\u0000\u0000\u0f9c\u01ad\u0001\u0000\u0000\u0000\u0f9d\u0f9e\u0005h\u0000"+ + "\u0000\u0f9e\u0f9f\u0005\u0003\u0000\u0000\u0f9f\u0fa0\u0003\u048c\u0246"+ + "\u0000\u0fa0\u0fa1\u0005\u0004\u0000\u0000\u0fa1\u0fa4\u0001\u0000\u0000"+ + "\u0000\u0fa2\u0fa4\u0001\u0000\u0000\u0000\u0fa3\u0f9d\u0001\u0000\u0000"+ + "\u0000\u0fa3\u0fa2\u0001\u0000\u0000\u0000\u0fa4\u01af\u0001\u0000\u0000"+ + "\u0000\u0fa5\u0fa6\u0007\u0016\u0000\u0000\u0fa6\u01b1\u0001\u0000\u0000"+ + "\u0000\u0fa7\u0faa\u0003\u01b4\u00da\u0000\u0fa8\u0faa\u0001\u0000\u0000"+ + "\u0000\u0fa9\u0fa7\u0001\u0000\u0000\u0000\u0fa9\u0fa8\u0001\u0000\u0000"+ + "\u0000\u0faa\u0faf\u0001\u0000\u0000\u0000\u0fab\u0fac\u0005\u0007\u0000"+ + "\u0000\u0fac\u0fae\u0003\u01b4\u00da\u0000\u0fad\u0fab\u0001\u0000\u0000"+ + "\u0000\u0fae\u0fb1\u0001\u0000\u0000\u0000\u0faf\u0fad\u0001\u0000\u0000"+ + "\u0000\u0faf\u0fb0\u0001\u0000\u0000\u0000\u0fb0\u01b3\u0001\u0000\u0000"+ + "\u0000\u0fb1\u0faf\u0001\u0000\u0000\u0000\u0fb2\u0fb7\u0003\u054c\u02a6"+ + "\u0000\u0fb3\u0fb7\u0003\u054a\u02a5\u0000\u0fb4\u0fb7\u0003\u054e\u02a7"+ + "\u0000\u0fb5\u0fb7\u0003\u0564\u02b2\u0000\u0fb6\u0fb2\u0001\u0000\u0000"+ + "\u0000\u0fb6\u0fb3\u0001\u0000\u0000\u0000\u0fb6\u0fb4\u0001\u0000\u0000"+ + "\u0000\u0fb6\u0fb5\u0001\u0000\u0000\u0000\u0fb7\u01b5\u0001\u0000\u0000"+ + "\u0000\u0fb8\u0fb9\u0005B\u0000\u0000\u0fb9\u0fbc\u0003\u0538\u029c\u0000"+ + "\u0fba\u0fbc\u0001\u0000\u0000\u0000\u0fbb\u0fb8\u0001\u0000\u0000\u0000"+ + "\u0fbb\u0fba\u0001\u0000\u0000\u0000\u0fbc\u01b7\u0001\u0000\u0000\u0000"+ + "\u0fbd\u0fbf\u0003\u01ba\u00dd\u0000\u0fbe\u0fbd\u0001\u0000\u0000\u0000"+ + "\u0fbf\u0fc2\u0001\u0000\u0000\u0000\u0fc0\u0fbe\u0001\u0000\u0000\u0000"+ + "\u0fc0\u0fc1\u0001\u0000\u0000\u0000\u0fc1\u01b9\u0001\u0000\u0000\u0000"+ + "\u0fc2\u0fc0\u0001\u0000\u0000\u0000\u0fc3\u0fc4\u0005O\u0000\u0000\u0fc4"+ + "\u0fcf\u00058\u0000\u0000\u0fc5\u0fcf\u00058\u0000\u0000\u0fc6\u0fc7\u0005"+ + "G\u0000\u0000\u0fc7\u0fcf\u0005\u00df\u0000\u0000\u0fc8\u0fc9\u0005G\u0000"+ + "\u0000\u0fc9\u0fcf\u0005\u00b6\u0000\u0000\u0fca\u0fcb\u0005O\u0000\u0000"+ + "\u0fcb\u0fcf\u0005\u016e\u0000\u0000\u0fcc\u0fcd\u0005\u0108\u0000\u0000"+ + "\u0fcd\u0fcf\u0005\u00e6\u0000\u0000\u0fce\u0fc3\u0001\u0000\u0000\u0000"+ + "\u0fce\u0fc5\u0001\u0000\u0000\u0000\u0fce\u0fc6\u0001\u0000\u0000\u0000"+ + "\u0fce\u0fc8\u0001\u0000\u0000\u0000\u0fce\u0fca\u0001\u0000\u0000\u0000"+ + "\u0fce\u0fcc\u0001\u0000\u0000\u0000\u0fcf\u01bb\u0001\u0000\u0000\u0000"+ + "\u0fd0\u0fd1\u00050\u0000\u0000\u0fd1\u0fd2\u0005\u00c8\u0000\u0000\u0fd2"+ + "\u0fd3\u0005\u0160\u0000\u0000\u0fd3\u0fd4\u0003\u053c\u029e\u0000\u0fd4"+ + "\u0fd5\u0005R\u0000\u0000\u0fd5\u0fd6\u0003\u0564\u02b2\u0000\u0fd6\u0fd7"+ + "\u0005\u00cc\u0000\u0000\u0fd7\u0fd8\u0003\u01b0\u00d8\u0000\u0fd8\u0fd9"+ + "\u0003\u0542\u02a1\u0000\u0fd9\u0fda\u0005\u0003\u0000\u0000\u0fda\u0fdb"+ + "\u0005\u0004\u0000\u0000\u0fdb\u0feb\u0001\u0000\u0000\u0000\u0fdc\u0fdd"+ + "\u00050\u0000\u0000\u0fdd\u0fde\u0005\u00c8\u0000\u0000\u0fde\u0fdf\u0005"+ + "\u0160\u0000\u0000\u0fdf\u0fe0\u0003\u053c\u029e\u0000\u0fe0\u0fe1\u0005"+ + "R\u0000\u0000\u0fe1\u0fe2\u0003\u0564\u02b2\u0000\u0fe2\u0fe3\u0005h\u0000"+ + "\u0000\u0fe3\u0fe4\u0003\u01be\u00df\u0000\u0fe4\u0fe5\u0005\u00cc\u0000"+ + "\u0000\u0fe5\u0fe6\u0003\u01b0\u00d8\u0000\u0fe6\u0fe7\u0003\u0542\u02a1"+ + "\u0000\u0fe7\u0fe8\u0005\u0003\u0000\u0000\u0fe8\u0fe9\u0005\u0004\u0000"+ + "\u0000\u0fe9\u0feb\u0001\u0000\u0000\u0000\u0fea\u0fd0\u0001\u0000\u0000"+ + "\u0000\u0fea\u0fdc\u0001\u0000\u0000\u0000\u0feb\u01bd\u0001\u0000\u0000"+ + "\u0000\u0fec\u0ff1\u0003\u01c0\u00e0\u0000\u0fed\u0fee\u0005#\u0000\u0000"+ + "\u0fee\u0ff0\u0003\u01c0\u00e0\u0000\u0fef\u0fed\u0001\u0000\u0000\u0000"+ + "\u0ff0\u0ff3\u0001\u0000\u0000\u0000\u0ff1\u0fef\u0001\u0000\u0000\u0000"+ + "\u0ff1\u0ff2\u0001\u0000\u0000\u0000\u0ff2\u01bf\u0001\u0000\u0000\u0000"+ + "\u0ff3\u0ff1\u0001\u0000\u0000\u0000\u0ff4\u0ff5\u0003\u055c\u02ae\u0000"+ + "\u0ff5\u0ff6\u0005F\u0000\u0000\u0ff6\u0ff7\u0005\u0003\u0000\u0000\u0ff7"+ + "\u0ff8\u0003\u01c2\u00e1\u0000\u0ff8\u0ff9\u0005\u0004\u0000\u0000\u0ff9"+ + "\u01c1\u0001\u0000\u0000\u0000\u0ffa\u0fff\u0003\u054e\u02a7\u0000\u0ffb"+ + "\u0ffc\u0005\u0007\u0000\u0000\u0ffc\u0ffe\u0003\u054e\u02a7\u0000\u0ffd"+ + "\u0ffb\u0001\u0000\u0000\u0000\u0ffe\u1001\u0001\u0000\u0000\u0000\u0fff"+ + "\u0ffd\u0001\u0000\u0000\u0000\u0fff\u1000\u0001\u0000\u0000\u0000\u1000"+ + "\u01c3\u0001\u0000\u0000\u0000\u1001\u0fff\u0001\u0000\u0000\u0000\u1002"+ + "\u1003\u0005\u008c\u0000\u0000\u1003\u1004\u0005\u00c8\u0000\u0000\u1004"+ + "\u1005\u0005\u0160\u0000\u0000\u1005\u1006\u0003\u053c\u029e\u0000\u1006"+ + "\u1007\u0003\u01c6\u00e3\u0000\u1007\u01c5\u0001\u0000\u0000\u0000\u1008"+ + "\u100f\u0005\u00c3\u0000\u0000\u1009\u100a\u0005\u00c3\u0000\u0000\u100a"+ + "\u100f\u0005\u0133\u0000\u0000\u100b\u100c\u0005\u00c3\u0000\u0000\u100c"+ + "\u100f\u0005\u008d\u0000\u0000\u100d\u100f\u0005\u00bc\u0000\u0000\u100e"+ + "\u1008\u0001\u0000\u0000\u0000\u100e\u1009\u0001\u0000\u0000\u0000\u100e"+ + "\u100b\u0001\u0000\u0000\u0000\u100e\u100d\u0001\u0000\u0000\u0000\u100f"+ + "\u01c7\u0001\u0000\u0000\u0000\u1010\u1011\u00050\u0000\u0000\u1011\u1012"+ + "\u0005\u008e\u0000\u0000\u1012\u1013\u0003\u020c\u0106\u0000\u1013\u1014"+ + "\u0005,\u0000\u0000\u1014\u1015\u0005\u0003\u0000\u0000\u1015\u1016\u0003"+ + "\u048c\u0246\u0000\u1016\u1017\u0005\u0004\u0000\u0000\u1017\u1018\u0003"+ + "\u01b8\u00dc\u0000\u1018\u01c9\u0001\u0000\u0000\u0000\u1019\u101a\u0005"+ + "0\u0000\u0000\u101a\u101b\u0003\u026a\u0135\u0000\u101b\u101c\u0005\u008a"+ + "\u0000\u0000\u101c\u101d\u0003\u0542\u02a1\u0000\u101d\u101e\u0003\u0286"+ + "\u0143\u0000\u101e\u101f\u0003\u01cc\u00e6\u0000\u101f\u1084\u0001\u0000"+ + "\u0000\u0000\u1020\u1021\u00050\u0000\u0000\u1021\u1022\u0003\u026a\u0135"+ + "\u0000\u1022\u1023\u0005\u008a\u0000\u0000\u1023\u1024\u0003\u0542\u02a1"+ + "\u0000\u1024\u1025\u0003\u01d4\u00ea\u0000\u1025\u1084\u0001\u0000\u0000"+ + "\u0000\u1026\u1027\u00050\u0000\u0000\u1027\u1028\u0005\u0111\u0000\u0000"+ + "\u1028\u1029\u0003\u02ac\u0156\u0000\u1029\u102a\u0003\u01cc\u00e6\u0000"+ + "\u102a\u1084\u0001\u0000\u0000\u0000\u102b\u102c\u00050\u0000\u0000\u102c"+ + "\u102d\u0005\u0163\u0000\u0000\u102d\u102e\u0003\u020c\u0106\u0000\u102e"+ + "\u102f\u0003\u01cc\u00e6\u0000\u102f\u1084\u0001\u0000\u0000\u0000\u1030"+ + "\u1031\u00050\u0000\u0000\u1031\u1032\u0005\u0163\u0000\u0000\u1032\u1084"+ + "\u0003\u020c\u0106\u0000\u1033\u1034\u00050\u0000\u0000\u1034\u1035\u0005"+ + "\u0163\u0000\u0000\u1035\u1036\u0003\u020c\u0106\u0000\u1036\u1037\u0005"+ + "&\u0000\u0000\u1037\u1038\u0005\u0003\u0000\u0000\u1038\u1039\u0003\u044c"+ + "\u0226\u0000\u1039\u103a\u0005\u0004\u0000\u0000\u103a\u1084\u0001\u0000"+ + "\u0000\u0000\u103b\u103c\u00050\u0000\u0000\u103c\u103d\u0005\u0163\u0000"+ + "\u0000\u103d\u103e\u0003\u020c\u0106\u0000\u103e\u103f\u0005&\u0000\u0000"+ + "\u103f\u1040\u0005\u00c6\u0000\u0000\u1040\u1041\u0005\u0003\u0000\u0000"+ + "\u1041\u1042\u0003\u01da\u00ed\u0000\u1042\u1043\u0005\u0004\u0000\u0000"+ + "\u1043\u1084\u0001\u0000\u0000\u0000\u1044\u1045\u00050\u0000\u0000\u1045"+ + "\u1046\u0005\u0163\u0000\u0000\u1046\u1047\u0003\u020c\u0106\u0000\u1047"+ + "\u1048\u0005&\u0000\u0000\u1048\u1049\u0005\u0126\u0000\u0000\u1049\u104a"+ + "\u0003\u01cc\u00e6\u0000\u104a\u1084\u0001\u0000\u0000\u0000\u104b\u104c"+ + "\u00050\u0000\u0000\u104c\u104d\u0005\u015e\u0000\u0000\u104d\u104e\u0005"+ + "\u0140\u0000\u0000\u104e\u104f\u0005\u0116\u0000\u0000\u104f\u1050\u0003"+ + "\u020c\u0106\u0000\u1050\u1051\u0003\u01cc\u00e6\u0000\u1051\u1084\u0001"+ + "\u0000\u0000\u0000\u1052\u1053\u00050\u0000\u0000\u1053\u1054\u0005\u015e"+ + "\u0000\u0000\u1054\u1055\u0005\u0140\u0000\u0000\u1055\u1056\u0005\u00bb"+ + "\u0000\u0000\u1056\u1057\u0003\u020c\u0106\u0000\u1057\u1058\u0003\u01cc"+ + "\u00e6\u0000\u1058\u1084\u0001\u0000\u0000\u0000\u1059\u105a\u00050\u0000"+ + "\u0000\u105a\u105b\u0005\u015e\u0000\u0000\u105b\u105c\u0005\u0140\u0000"+ + "\u0000\u105c\u105d\u0005\u015c\u0000\u0000\u105d\u105e\u0003\u020c\u0106"+ + "\u0000\u105e\u105f\u0003\u01cc\u00e6\u0000\u105f\u1084\u0001\u0000\u0000"+ + "\u0000\u1060\u1061\u00050\u0000\u0000\u1061\u1062\u0005\u015e\u0000\u0000"+ + "\u1062\u1063\u0005\u0140\u0000\u0000\u1063\u1064\u0005\u00a5\u0000\u0000"+ + "\u1064\u1065\u0003\u020c\u0106\u0000\u1065\u1066\u0003\u01cc\u00e6\u0000"+ + "\u1066\u1084\u0001\u0000\u0000\u0000\u1067\u1068\u00050\u0000\u0000\u1068"+ + "\u1069\u0005n\u0000\u0000\u1069\u106a\u0003\u020c\u0106\u0000\u106a\u106b"+ + "\u0003\u01cc\u00e6\u0000\u106b\u1084\u0001\u0000\u0000\u0000\u106c\u106d"+ + "\u00050\u0000\u0000\u106d\u106e\u0005n\u0000\u0000\u106e\u106f\u0005\u00de"+ + "\u0000\u0000\u106f\u1070\u0005O\u0000\u0000\u1070\u1071\u0005\u0187\u0000"+ + "\u0000\u1071\u1072\u0003\u020c\u0106\u0000\u1072\u1073\u0003\u01cc\u00e6"+ + "\u0000\u1073\u1084\u0001\u0000\u0000\u0000\u1074\u1075\u00050\u0000\u0000"+ + "\u1075\u1076\u0005n\u0000\u0000\u1076\u1077\u0003\u020c\u0106\u0000\u1077"+ + "\u1078\u0005B\u0000\u0000\u1078\u1079\u0003\u020c\u0106\u0000\u1079\u1084"+ + "\u0001\u0000\u0000\u0000\u107a\u107b\u00050\u0000\u0000\u107b\u107c\u0005"+ + "n\u0000\u0000\u107c\u107d\u0005\u00de\u0000\u0000\u107d\u107e\u0005O\u0000"+ + "\u0000\u107e\u107f\u0005\u0187\u0000\u0000\u107f\u1080\u0003\u020c\u0106"+ + "\u0000\u1080\u1081\u0005B\u0000\u0000\u1081\u1082\u0003\u020c\u0106\u0000"+ + "\u1082\u1084\u0001\u0000\u0000\u0000\u1083\u1019\u0001\u0000\u0000\u0000"+ + "\u1083\u1020\u0001\u0000\u0000\u0000\u1083\u1026\u0001\u0000\u0000\u0000"+ + "\u1083\u102b\u0001\u0000\u0000\u0000\u1083\u1030\u0001\u0000\u0000\u0000"+ + "\u1083\u1033\u0001\u0000\u0000\u0000\u1083\u103b\u0001\u0000\u0000\u0000"+ + "\u1083\u1044\u0001\u0000\u0000\u0000\u1083\u104b\u0001\u0000\u0000\u0000"+ + "\u1083\u1052\u0001\u0000\u0000\u0000\u1083\u1059\u0001\u0000\u0000\u0000"+ + "\u1083\u1060\u0001\u0000\u0000\u0000\u1083\u1067\u0001\u0000\u0000\u0000"+ + "\u1083\u106c\u0001\u0000\u0000\u0000\u1083\u1074\u0001\u0000\u0000\u0000"+ + "\u1083\u107a\u0001\u0000\u0000\u0000\u1084\u01cb\u0001\u0000\u0000\u0000"+ + "\u1085\u1086\u0005\u0003\u0000\u0000\u1086\u1087\u0003\u01ce\u00e7\u0000"+ + "\u1087\u1088\u0005\u0004\u0000\u0000\u1088\u01cd\u0001\u0000\u0000\u0000"+ + "\u1089\u108e\u0003\u01d0\u00e8\u0000\u108a\u108b\u0005\u0007\u0000\u0000"+ + "\u108b\u108d\u0003\u01d0\u00e8\u0000\u108c\u108a\u0001\u0000\u0000\u0000"+ + "\u108d\u1090\u0001\u0000\u0000\u0000\u108e\u108c\u0001\u0000\u0000\u0000"+ + "\u108e\u108f\u0001\u0000\u0000\u0000\u108f\u01cf\u0001\u0000\u0000\u0000"+ + "\u1090\u108e\u0001\u0000\u0000\u0000\u1091\u1094\u0003\u0564\u02b2\u0000"+ + "\u1092\u1093\u0005\f\u0000\u0000\u1093\u1095\u0003\u01d2\u00e9\u0000\u1094"+ + "\u1092\u0001\u0000\u0000\u0000\u1094\u1095\u0001\u0000\u0000\u0000\u1095"+ + "\u01d1\u0001\u0000\u0000\u0000\u1096\u109d\u0003\u0280\u0140\u0000\u1097"+ + "\u109d\u0003\u0570\u02b8\u0000\u1098\u109d\u0003\u04fc\u027e\u0000\u1099"+ + "\u109d\u0003\u0124\u0092\u0000\u109a\u109d\u0003\u054e\u02a7\u0000\u109b"+ + "\u109d\u0005\u0192\u0000\u0000\u109c\u1096\u0001\u0000\u0000\u0000\u109c"+ + "\u1097\u0001\u0000\u0000\u0000\u109c\u1098\u0001\u0000\u0000\u0000\u109c"+ + "\u1099\u0001\u0000\u0000\u0000\u109c\u109a\u0001\u0000\u0000\u0000\u109c"+ + "\u109b\u0001\u0000\u0000\u0000\u109d\u01d3\u0001\u0000\u0000\u0000\u109e"+ + "\u109f\u0005\u0003\u0000\u0000\u109f\u10a0\u0003\u01d6\u00eb\u0000\u10a0"+ + "\u10a1\u0005\u0004\u0000\u0000\u10a1\u01d5\u0001\u0000\u0000\u0000\u10a2"+ + "\u10a7\u0003\u01d8\u00ec\u0000\u10a3\u10a4\u0005\u0007\u0000\u0000\u10a4"+ + "\u10a6\u0003\u01d8\u00ec\u0000\u10a5\u10a3\u0001\u0000\u0000\u0000\u10a6"+ + "\u10a9\u0001\u0000\u0000\u0000\u10a7\u10a5\u0001\u0000\u0000\u0000\u10a7"+ + "\u10a8\u0001\u0000\u0000\u0000\u10a8\u01d7\u0001\u0000\u0000\u0000\u10a9"+ + "\u10a7\u0001\u0000\u0000\u0000\u10aa\u10ab\u0003\u0566\u02b3\u0000\u10ab"+ + "\u10ac\u0005\f\u0000\u0000\u10ac\u10ad\u0003\u01d2\u00e9\u0000\u10ad\u01d9"+ + "\u0001\u0000\u0000\u0000\u10ae\u10b1\u0003\u01dc\u00ee\u0000\u10af\u10b1"+ + "\u0001\u0000\u0000\u0000\u10b0\u10ae\u0001\u0000\u0000\u0000\u10b0\u10af"+ + "\u0001\u0000\u0000\u0000\u10b1\u01db\u0001\u0000\u0000\u0000\u10b2\u10b7"+ + "\u0003\u054e\u02a7\u0000\u10b3\u10b4\u0005\u0007\u0000\u0000\u10b4\u10b6"+ + "\u0003\u054e\u02a7\u0000\u10b5\u10b3\u0001\u0000\u0000\u0000\u10b6\u10b9"+ + "\u0001\u0000\u0000\u0000\u10b7\u10b5\u0001\u0000\u0000\u0000\u10b7\u10b8"+ + "\u0001\u0000\u0000\u0000\u10b8\u01dd\u0001\u0000\u0000\u0000\u10b9\u10b7"+ + "\u0001\u0000\u0000\u0000\u10ba\u10bb\u0005\u008c\u0000\u0000\u10bb\u10bc"+ + "\u0005\u0163\u0000\u0000\u10bc\u10bd\u0003\u020c\u0106\u0000\u10bd\u10be"+ + "\u0005\u0087\u0000\u0000\u10be\u10bf\u0005\u01c4\u0000\u0000\u10bf\u10c0"+ + "\u0003\u01e0\u00f0\u0000\u10c0\u10c1\u0003\u054e\u02a7\u0000\u10c1\u10e0"+ + "\u0001\u0000\u0000\u0000\u10c2\u10c3\u0005\u008c\u0000\u0000\u10c3\u10c4"+ + "\u0005\u0163\u0000\u0000\u10c4\u10c5\u0003\u020c\u0106\u0000\u10c5\u10c6"+ + "\u0005\u0087\u0000\u0000\u10c6\u10c7\u0005\u01c4\u0000\u0000\u10c7\u10c8"+ + "\u0003\u01e0\u00f0\u0000\u10c8\u10c9\u0003\u054e\u02a7\u0000\u10c9\u10ca"+ + "\u0005\u0093\u0000\u0000\u10ca\u10cb\u0003\u054e\u02a7\u0000\u10cb\u10e0"+ + "\u0001\u0000\u0000\u0000\u10cc\u10cd\u0005\u008c\u0000\u0000\u10cd\u10ce"+ + "\u0005\u0163\u0000\u0000\u10ce\u10cf\u0003\u020c\u0106\u0000\u10cf\u10d0"+ + "\u0005\u0087\u0000\u0000\u10d0\u10d1\u0005\u01c4\u0000\u0000\u10d1\u10d2"+ + "\u0003\u01e0\u00f0\u0000\u10d2\u10d3\u0003\u054e\u02a7\u0000\u10d3\u10d4"+ + "\u0005\u0089\u0000\u0000\u10d4\u10d5\u0003\u054e\u02a7\u0000\u10d5\u10e0"+ + "\u0001\u0000\u0000\u0000\u10d6\u10d7\u0005\u008c\u0000\u0000\u10d7\u10d8"+ + "\u0005\u0163\u0000\u0000\u10d8\u10d9\u0003\u020c\u0106\u0000\u10d9\u10da"+ + "\u0005\u0130\u0000\u0000\u10da\u10db\u0005\u01c4\u0000\u0000\u10db\u10dc"+ + "\u0003\u054e\u02a7\u0000\u10dc\u10dd\u0005`\u0000\u0000\u10dd\u10de\u0003"+ + "\u054e\u02a7\u0000\u10de\u10e0\u0001\u0000\u0000\u0000\u10df\u10ba\u0001"+ + "\u0000\u0000\u0000\u10df\u10c2\u0001\u0000\u0000\u0000\u10df\u10cc\u0001"+ + "\u0000\u0000\u0000\u10df\u10d6\u0001\u0000\u0000\u0000\u10e0\u01df\u0001"+ + "\u0000\u0000\u0000\u10e1\u10e2\u0005\u00de\u0000\u0000\u10e2\u10e3\u0005"+ + "O\u0000\u0000\u10e3\u10e6\u0005\u0187\u0000\u0000\u10e4\u10e6\u0001\u0000"+ + "\u0000\u0000\u10e5\u10e1\u0001\u0000\u0000\u0000\u10e5\u10e4\u0001\u0000"+ + "\u0000\u0000\u10e6\u01e1\u0001\u0000\u0000\u0000\u10e7\u10e8\u00050\u0000"+ + "\u0000\u10e8\u10e9\u0005\u0111\u0000\u0000\u10e9\u10ea\u0005\u009e\u0000"+ + "\u0000\u10ea\u10eb\u0003\u020c\u0106\u0000\u10eb\u10ec\u0003\u01e8\u00f4"+ + "\u0000\u10ec\u10ed\u0005@\u0000\u0000\u10ed\u10ee\u0005\u0163\u0000\u0000"+ + "\u10ee\u10ef\u0003\u0460\u0230\u0000\u10ef\u10f0\u0005f\u0000\u0000\u10f0"+ + "\u10f1\u0003\u053c\u029e\u0000\u10f1\u10f2\u0003\u01ea\u00f5\u0000\u10f2"+ + "\u10f3\u0005&\u0000\u0000\u10f3\u10f4\u0003\u01e4\u00f2\u0000\u10f4\u01e3"+ + "\u0001\u0000\u0000\u0000\u10f5\u10fa\u0003\u01e6\u00f3\u0000\u10f6\u10f7"+ + "\u0005\u0007\u0000\u0000\u10f7\u10f9\u0003\u01e6\u00f3\u0000\u10f8\u10f6"+ + "\u0001\u0000\u0000\u0000\u10f9\u10fc\u0001\u0000\u0000\u0000\u10fa\u10f8"+ + "\u0001\u0000\u0000\u0000\u10fa\u10fb\u0001\u0000\u0000\u0000\u10fb\u01e5"+ + "\u0001\u0000\u0000\u0000\u10fc\u10fa\u0001\u0000\u0000\u0000\u10fd\u10fe"+ + "\u0005\u0111\u0000\u0000\u10fe\u10ff\u0003\u054c\u02a6\u0000\u10ff\u1100"+ + "\u0003\u02ac\u0156\u0000\u1100\u1101\u0003\u01ec\u00f6\u0000\u1101\u1102"+ + "\u0003\u01ee\u00f7\u0000\u1102\u1117\u0001\u0000\u0000\u0000\u1103\u1104"+ + "\u0005\u0111\u0000\u0000\u1104\u1105\u0003\u054c\u02a6\u0000\u1105\u1106"+ + "\u0003\u02b0\u0158\u0000\u1106\u1107\u0003\u01ec\u00f6\u0000\u1107\u1108"+ + "\u0003\u01ee\u00f7\u0000\u1108\u1117\u0001\u0000\u0000\u0000\u1109\u110a"+ + "\u0005\u00d5\u0000\u0000\u110a\u110b\u0003\u054c\u02a6\u0000\u110b\u110c"+ + "\u0003\u0272\u0139\u0000\u110c\u1117\u0001\u0000\u0000\u0000\u110d\u110e"+ + "\u0005\u00d5\u0000\u0000\u110e\u110f\u0003\u054c\u02a6\u0000\u110f\u1110"+ + "\u0005\u0003\u0000\u0000\u1110\u1111\u0003\u0506\u0283\u0000\u1111\u1112"+ + "\u0005\u0004\u0000\u0000\u1112\u1113\u0003\u0272\u0139\u0000\u1113\u1117"+ + "\u0001\u0000\u0000\u0000\u1114\u1115\u0005\u0154\u0000\u0000\u1115\u1117"+ + "\u0003\u0460\u0230\u0000\u1116\u10fd\u0001\u0000\u0000\u0000\u1116\u1103"+ + "\u0001\u0000\u0000\u0000\u1116\u1109\u0001\u0000\u0000\u0000\u1116\u110d"+ + "\u0001\u0000\u0000\u0000\u1116\u1114\u0001\u0000\u0000\u0000\u1117\u01e7"+ + "\u0001\u0000\u0000\u0000\u1118\u111b\u00057\u0000\u0000\u1119\u111b\u0001"+ + "\u0000\u0000\u0000\u111a\u1118\u0001\u0000\u0000\u0000\u111a\u1119\u0001"+ + "\u0000\u0000\u0000\u111b\u01e9\u0001\u0000\u0000\u0000\u111c\u111d\u0005"+ + "\u00d0\u0000\u0000\u111d\u1120\u0003\u020c\u0106\u0000\u111e\u1120\u0001"+ + "\u0000\u0000\u0000\u111f\u111c\u0001\u0000\u0000\u0000\u111f\u111e\u0001"+ + "\u0000\u0000\u0000\u1120\u01eb\u0001\u0000\u0000\u0000\u1121\u1122\u0005"+ + "@\u0000\u0000\u1122\u1129\u0005\u0140\u0000\u0000\u1123\u1124\u0005@\u0000"+ + "\u0000\u1124\u1125\u0005U\u0000\u0000\u1125\u1126\u0005\u0095\u0000\u0000"+ + "\u1126\u1129\u0003\u020c\u0106\u0000\u1127\u1129\u0001\u0000\u0000\u0000"+ + "\u1128\u1121\u0001\u0000\u0000\u0000\u1128\u1123\u0001\u0000\u0000\u0000"+ + "\u1128\u1127\u0001\u0000\u0000\u0000\u1129\u01ed\u0001\u0000\u0000\u0000"+ + "\u112a\u112d\u0005\u0129\u0000\u0000\u112b\u112d\u0001\u0000\u0000\u0000"+ + "\u112c\u112a\u0001\u0000\u0000\u0000\u112c\u112b\u0001\u0000\u0000\u0000"+ + "\u112d\u01ef\u0001\u0000\u0000\u0000\u112e\u112f\u00050\u0000\u0000\u112f"+ + "\u1130\u0005\u0111\u0000\u0000\u1130\u1131\u0005\u00d0\u0000\u0000\u1131"+ + "\u1132\u0003\u020c\u0106\u0000\u1132\u1133\u0005f\u0000\u0000\u1133\u1134"+ + "\u0003\u053c\u029e\u0000\u1134\u01f1\u0001\u0000\u0000\u0000\u1135\u1136"+ + "\u0005\u008c\u0000\u0000\u1136\u1137\u0005\u0111\u0000\u0000\u1137\u1138"+ + "\u0005\u00d0\u0000\u0000\u1138\u1139\u0003\u020c\u0106\u0000\u1139\u113a"+ + "\u0005f\u0000\u0000\u113a\u113b\u0003\u053c\u029e\u0000\u113b\u113c\u0005"+ + "\u0087\u0000\u0000\u113c\u113d\u0003\u01e4\u00f2\u0000\u113d\u1148\u0001"+ + "\u0000\u0000\u0000\u113e\u113f\u0005\u008c\u0000\u0000\u113f\u1140\u0005"+ + "\u0111\u0000\u0000\u1140\u1141\u0005\u00d0\u0000\u0000\u1141\u1142\u0003"+ + "\u020c\u0106\u0000\u1142\u1143\u0005f\u0000\u0000\u1143\u1144\u0003\u053c"+ + "\u029e\u0000\u1144\u1145\u0005\u00c1\u0000\u0000\u1145\u1146\u0003\u01f4"+ + "\u00fa\u0000\u1146\u1148\u0001\u0000\u0000\u0000\u1147\u1135\u0001\u0000"+ + "\u0000\u0000\u1147\u113e\u0001\u0000\u0000\u0000\u1148\u01f3\u0001\u0000"+ + "\u0000\u0000\u1149\u114e\u0003\u01f6\u00fb\u0000\u114a\u114b\u0005\u0007"+ + "\u0000\u0000\u114b\u114d\u0003\u01f6\u00fb\u0000\u114c\u114a\u0001\u0000"+ + "\u0000\u0000\u114d\u1150\u0001\u0000\u0000\u0000\u114e\u114c\u0001\u0000"+ + "\u0000\u0000\u114e\u114f\u0001\u0000\u0000\u0000\u114f\u01f5\u0001\u0000"+ + "\u0000\u0000\u1150\u114e\u0001\u0000\u0000\u0000\u1151\u1152\u0005\u0111"+ + "\u0000\u0000\u1152\u1153\u0003\u054c\u02a6\u0000\u1153\u1154\u0005\u0003"+ + "\u0000\u0000\u1154\u1155\u0003\u0506\u0283\u0000\u1155\u1156\u0005\u0004"+ + "\u0000\u0000\u1156\u115e\u0001\u0000\u0000\u0000\u1157\u1158\u0005\u00d5"+ + "\u0000\u0000\u1158\u1159\u0003\u054c\u02a6\u0000\u1159\u115a\u0005\u0003"+ + "\u0000\u0000\u115a\u115b\u0003\u0506\u0283\u0000\u115b\u115c\u0005\u0004"+ + "\u0000\u0000\u115c\u115e\u0001\u0000\u0000\u0000\u115d\u1151\u0001\u0000"+ + "\u0000\u0000\u115d\u1157\u0001\u0000\u0000\u0000\u115e\u01f7\u0001\u0000"+ + "\u0000\u0000\u115f\u1160\u0005\u00c1\u0000\u0000\u1160\u1161\u0005\u0111"+ + "\u0000\u0000\u1161\u1162\u0005\u009e\u0000\u0000\u1162\u1163\u0003\u020c"+ + "\u0106\u0000\u1163\u1164\u0005f\u0000\u0000\u1164\u1165\u0003\u053c\u029e"+ + "\u0000\u1165\u1166\u0003l6\u0000\u1166\u1172\u0001\u0000\u0000\u0000\u1167"+ + "\u1168\u0005\u00c1\u0000\u0000\u1168\u1169\u0005\u0111\u0000\u0000\u1169"+ + "\u116a\u0005\u009e\u0000\u0000\u116a\u116b\u0005\u00de\u0000\u0000\u116b"+ + "\u116c\u0005\u0187\u0000\u0000\u116c\u116d\u0003\u020c\u0106\u0000\u116d"+ + "\u116e\u0005f\u0000\u0000\u116e\u116f\u0003\u053c\u029e\u0000\u116f\u1170"+ + "\u0003l6\u0000\u1170\u1172\u0001\u0000\u0000\u0000\u1171\u115f\u0001\u0000"+ + "\u0000\u0000\u1171\u1167\u0001\u0000\u0000\u0000\u1172\u01f9\u0001\u0000"+ + "\u0000\u0000\u1173\u1174\u0005\u00c1\u0000\u0000\u1174\u1175\u0005\u0111"+ + "\u0000\u0000\u1175\u1176\u0005\u00d0\u0000\u0000\u1176\u1177\u0003\u020c"+ + "\u0106\u0000\u1177\u1178\u0005f\u0000\u0000\u1178\u1179\u0003\u053c\u029e"+ + "\u0000\u1179\u117a\u0003l6\u0000\u117a\u1186\u0001\u0000\u0000\u0000\u117b"+ + "\u117c\u0005\u00c1\u0000\u0000\u117c\u117d\u0005\u0111\u0000\u0000\u117d"+ + "\u117e\u0005\u00d0\u0000\u0000\u117e\u117f\u0005\u00de\u0000\u0000\u117f"+ + "\u1180\u0005\u0187\u0000\u0000\u1180\u1181\u0003\u020c\u0106\u0000\u1181"+ + "\u1182\u0005f\u0000\u0000\u1182\u1183\u0003\u053c\u029e\u0000\u1183\u1184"+ + "\u0003l6\u0000\u1184\u1186\u0001\u0000\u0000\u0000\u1185\u1173\u0001\u0000"+ + "\u0000\u0000\u1185\u117b\u0001\u0000\u0000\u0000\u1186\u01fb\u0001\u0000"+ + "\u0000\u0000\u1187\u1188\u0005\u00c1\u0000\u0000\u1188\u1189\u0005\u0114"+ + "\u0000\u0000\u1189\u118a\u0005\u0095\u0000\u0000\u118a\u118b\u0003\u055a"+ + "\u02ad\u0000\u118b\u118c\u0003l6\u0000\u118c\u01fd\u0001\u0000\u0000\u0000"+ + "\u118d\u118e\u0005\u0128\u0000\u0000\u118e\u118f\u0005\u0114\u0000\u0000"+ + "\u118f\u1190\u0005\u0095\u0000\u0000\u1190\u1191\u0003\u055a\u02ad\u0000"+ + "\u1191\u1192\u0005`\u0000\u0000\u1192\u1193\u0003\u0558\u02ac\u0000\u1193"+ + "\u01ff\u0001\u0000\u0000\u0000\u1194\u1195\u0005\u00c1\u0000\u0000\u1195"+ + "\u1196\u0003\u0202\u0101\u0000\u1196\u1197\u0005\u00de\u0000\u0000\u1197"+ + "\u1198\u0005\u0187\u0000\u0000\u1198\u1199\u0003\u020a\u0105\u0000\u1199"+ + "\u119a\u0003l6\u0000\u119a\u11e3\u0001\u0000\u0000\u0000\u119b\u119c\u0005"+ + "\u00c1\u0000\u0000\u119c\u119d\u0003\u0202\u0101\u0000\u119d\u119e\u0003"+ + "\u020a\u0105\u0000\u119e\u119f\u0003l6\u0000\u119f\u11e3\u0001\u0000\u0000"+ + "\u0000\u11a0\u11a1\u0005\u00c1\u0000\u0000\u11a1\u11a2\u0003\u0206\u0103"+ + "\u0000\u11a2\u11a3\u0005\u00de\u0000\u0000\u11a3\u11a4\u0005\u0187\u0000"+ + "\u0000\u11a4\u11a5\u0003\u053a\u029d\u0000\u11a5\u11a6\u0003l6\u0000\u11a6"+ + "\u11e3\u0001\u0000\u0000\u0000\u11a7\u11a8\u0005\u00c1\u0000\u0000\u11a8"+ + "\u11a9\u0003\u0206\u0103\u0000\u11a9\u11aa\u0003\u053a\u029d\u0000\u11aa"+ + "\u11ab\u0003l6\u0000\u11ab\u11e3\u0001\u0000\u0000\u0000\u11ac\u11ad\u0005"+ + "\u00c1\u0000\u0000\u11ad\u11ae\u0003\u0208\u0104\u0000\u11ae\u11af\u0003"+ + "\u053c\u029e\u0000\u11af\u11b0\u0005R\u0000\u0000\u11b0\u11b1\u0003\u020c"+ + "\u0106\u0000\u11b1\u11b2\u0003l6\u0000\u11b2\u11e3\u0001\u0000\u0000\u0000"+ + "\u11b3\u11b4\u0005\u00c1\u0000\u0000\u11b4\u11b5\u0003\u0208\u0104\u0000"+ + "\u11b5\u11b6\u0005\u00de\u0000\u0000\u11b6\u11b7\u0005\u0187\u0000\u0000"+ + "\u11b7\u11b8\u0003\u053c\u029e\u0000\u11b8\u11b9\u0005R\u0000\u0000\u11b9"+ + "\u11ba\u0003\u020c\u0106\u0000\u11ba\u11bb\u0003l6\u0000\u11bb\u11e3\u0001"+ + "\u0000\u0000\u0000\u11bc\u11bd\u0005\u00c1\u0000\u0000\u11bd\u11be\u0005"+ + "\u0163\u0000\u0000\u11be\u11bf\u0003\u0210\u0108\u0000\u11bf\u11c0\u0003"+ + "l6\u0000\u11c0\u11e3\u0001\u0000\u0000\u0000\u11c1\u11c2\u0005\u00c1\u0000"+ + "\u0000\u11c2\u11c3\u0005\u0163\u0000\u0000\u11c3\u11c4\u0005\u00de\u0000"+ + "\u0000\u11c4\u11c5\u0005\u0187\u0000\u0000\u11c5\u11c6\u0003\u0210\u0108"+ + "\u0000\u11c6\u11c7\u0003l6\u0000\u11c7\u11e3\u0001\u0000\u0000\u0000\u11c8"+ + "\u11c9\u0005\u00c1\u0000\u0000\u11c9\u11ca\u0005\u00bf\u0000\u0000\u11ca"+ + "\u11cb\u0003\u0210\u0108\u0000\u11cb\u11cc\u0003l6\u0000\u11cc\u11e3\u0001"+ + "\u0000\u0000\u0000\u11cd\u11ce\u0005\u00c1\u0000\u0000\u11ce\u11cf\u0005"+ + "\u00bf\u0000\u0000\u11cf\u11d0\u0005\u00de\u0000\u0000\u11d0\u11d1\u0005"+ + "\u0187\u0000\u0000\u11d1\u11d2\u0003\u0210\u0108\u0000\u11d2\u11d3\u0003"+ + "l6\u0000\u11d3\u11e3\u0001\u0000\u0000\u0000\u11d4\u11d5\u0005\u00c1\u0000"+ + "\u0000\u11d5\u11d6\u0005\u00e4\u0000\u0000\u11d6\u11d7\u0005o\u0000\u0000"+ + "\u11d7\u11d8\u0003\u020a\u0105\u0000\u11d8\u11d9\u0003l6\u0000\u11d9\u11e3"+ + "\u0001\u0000\u0000\u0000\u11da\u11db\u0005\u00c1\u0000\u0000\u11db\u11dc"+ + "\u0005\u00e4\u0000\u0000\u11dc\u11dd\u0005o\u0000\u0000\u11dd\u11de\u0005"+ + "\u00de\u0000\u0000\u11de\u11df\u0005\u0187\u0000\u0000\u11df\u11e0\u0003"+ + "\u020a\u0105\u0000\u11e0\u11e1\u0003l6\u0000\u11e1\u11e3\u0001\u0000\u0000"+ + "\u0000\u11e2\u1194\u0001\u0000\u0000\u0000\u11e2\u119b\u0001\u0000\u0000"+ + "\u0000\u11e2\u11a0\u0001\u0000\u0000\u0000\u11e2\u11a7\u0001\u0000\u0000"+ + "\u0000\u11e2\u11ac\u0001\u0000\u0000\u0000\u11e2\u11b3\u0001\u0000\u0000"+ + "\u0000\u11e2\u11bc\u0001\u0000\u0000\u0000\u11e2\u11c1\u0001\u0000\u0000"+ + "\u0000\u11e2\u11c8\u0001\u0000\u0000\u0000\u11e2\u11cd\u0001\u0000\u0000"+ + "\u0000\u11e2\u11d4\u0001\u0000\u0000\u0000\u11e2\u11da\u0001\u0000\u0000"+ + "\u0000\u11e3\u0201\u0001\u0000\u0000\u0000\u11e4\u11fc\u0005^\u0000\u0000"+ + "\u11e5\u11fc\u0005\u0143\u0000\u0000\u11e6\u11fc\u0005\u0173\u0000\u0000"+ + "\u11e7\u11e8\u0005\u00fd\u0000\u0000\u11e8\u11fc\u0005\u0173\u0000\u0000"+ + "\u11e9\u11fc\u0005\u00e4\u0000\u0000\u11ea\u11eb\u0005A\u0000\u0000\u11eb"+ + "\u11fc\u0005^\u0000\u0000\u11ec\u11fc\u0005n\u0000\u0000\u11ed\u11fc\u0005"+ + "\u00aa\u0000\u0000\u11ee\u11fc\u0005\u0151\u0000\u0000\u11ef\u11f0\u0005"+ + "\u015e\u0000\u0000\u11f0\u11f1\u0005\u0140\u0000\u0000\u11f1\u11fc\u0005"+ + "\u0116\u0000\u0000\u11f2\u11f3\u0005\u015e\u0000\u0000\u11f3\u11f4\u0005"+ + "\u0140\u0000\u0000\u11f4\u11fc\u0005\u00bb\u0000\u0000\u11f5\u11f6\u0005"+ + "\u015e\u0000\u0000\u11f6\u11f7\u0005\u0140\u0000\u0000\u11f7\u11fc\u0005"+ + "\u015c\u0000\u0000\u11f8\u11f9\u0005\u015e\u0000\u0000\u11f9\u11fa\u0005"+ + "\u0140\u0000\u0000\u11fa\u11fc\u0005\u00a5\u0000\u0000\u11fb\u11e4\u0001"+ + "\u0000\u0000\u0000\u11fb\u11e5\u0001\u0000\u0000\u0000\u11fb\u11e6\u0001"+ + "\u0000\u0000\u0000\u11fb\u11e7\u0001\u0000\u0000\u0000\u11fb\u11e9\u0001"+ + "\u0000\u0000\u0000\u11fb\u11ea\u0001\u0000\u0000\u0000\u11fb\u11ec\u0001"+ + "\u0000\u0000\u0000\u11fb\u11ed\u0001\u0000\u0000\u0000\u11fb\u11ee\u0001"+ + "\u0000\u0000\u0000\u11fb\u11ef\u0001\u0000\u0000\u0000\u11fb\u11f2\u0001"+ + "\u0000\u0000\u0000\u11fb\u11f5\u0001\u0000\u0000\u0000\u11fb\u11f8\u0001"+ + "\u0000\u0000\u0000\u11fc\u0203\u0001\u0000\u0000\u0000\u11fd\u1203\u0003"+ + "\u0206\u0103\u0000\u11fe\u1203\u0005\u00b1\u0000\u0000\u11ff\u1203\u0005"+ + "\u0139\u0000\u0000\u1200\u1203\u0005\u01c5\u0000\u0000\u1201\u1203\u0005"+ + "\u015a\u0000\u0000\u1202\u11fd\u0001\u0000\u0000\u0000\u1202\u11fe\u0001"+ + "\u0000\u0000\u0000\u1202\u11ff\u0001\u0000\u0000\u0000\u1202\u1200\u0001"+ + "\u0000\u0000\u0000\u1202\u1201\u0001\u0000\u0000\u0000\u1203\u0205\u0001"+ + "\u0000\u0000\u0000\u1204\u1205\u0005\u0085\u0000\u0000\u1205\u1213\u0005"+ + "\u01c0\u0000\u0000\u1206\u1207\u0005\u00c8\u0000\u0000\u1207\u1213\u0005"+ + "\u0160\u0000\u0000\u1208\u1213\u0005\u00ce\u0000\u0000\u1209\u120a\u0005"+ + "A\u0000\u0000\u120a\u120b\u0005\u00b0\u0000\u0000\u120b\u1213\u0005\u0178"+ + "\u0000\u0000\u120c\u120d\u0003\u0134\u009a\u0000\u120d\u120e\u0005\u00f0"+ + "\u0000\u0000\u120e\u1213\u0001\u0000\u0000\u0000\u120f\u1213\u0005\u01c6"+ + "\u0000\u0000\u1210\u1213\u0005\u013e\u0000\u0000\u1211\u1213\u0005\u0146"+ + "\u0000\u0000\u1212\u1204\u0001\u0000\u0000\u0000\u1212\u1206\u0001\u0000"+ + "\u0000\u0000\u1212\u1208\u0001\u0000\u0000\u0000\u1212\u1209\u0001\u0000"+ + "\u0000\u0000\u1212\u120c\u0001\u0000\u0000\u0000\u1212\u120f\u0001\u0000"+ + "\u0000\u0000\u1212\u1210\u0001\u0000\u0000\u0000\u1212\u1211\u0001\u0000"+ + "\u0000\u0000\u1213\u0207\u0001\u0000\u0000\u0000\u1214\u1215\u0007\u0017"+ + "\u0000\u0000\u1215\u0209\u0001\u0000\u0000\u0000\u1216\u121b\u0003\u020c"+ + "\u0106\u0000\u1217\u1218\u0005\u0007\u0000\u0000\u1218\u121a\u0003\u020c"+ + "\u0106\u0000\u1219\u1217\u0001\u0000\u0000\u0000\u121a\u121d\u0001\u0000"+ + "\u0000\u0000\u121b\u1219\u0001\u0000\u0000\u0000\u121b\u121c\u0001\u0000"+ + "\u0000\u0000\u121c\u020b\u0001\u0000\u0000\u0000\u121d\u121b\u0001\u0000"+ + "\u0000\u0000\u121e\u1220\u0003\u055c\u02ae\u0000\u121f\u1221\u0003\u020e"+ + "\u0107\u0000\u1220\u121f\u0001\u0000\u0000\u0000\u1220\u1221\u0001\u0000"+ + "\u0000\u0000\u1221\u020d\u0001\u0000\u0000\u0000\u1222\u1223\u0005\r\u0000"+ + "\u0000\u1223\u1225\u0003\u053e\u029f\u0000\u1224\u1222\u0001\u0000\u0000"+ + "\u0000\u1225\u1226\u0001\u0000\u0000\u0000\u1226\u1224\u0001\u0000\u0000"+ + "\u0000\u1226\u1227\u0001\u0000\u0000\u0000\u1227\u020f\u0001\u0000\u0000"+ + "\u0000\u1228\u122d\u0003\u0460\u0230\u0000\u1229\u122a\u0005\u0007\u0000"+ + "\u0000\u122a\u122c\u0003\u0460\u0230\u0000\u122b\u1229\u0001\u0000\u0000"+ + "\u0000\u122c\u122f\u0001\u0000\u0000\u0000\u122d\u122b\u0001\u0000\u0000"+ + "\u0000\u122d\u122e\u0001\u0000\u0000\u0000\u122e\u0211\u0001\u0000\u0000"+ + "\u0000\u122f\u122d\u0001\u0000\u0000\u0000\u1230\u1231\u0005\u0161\u0000"+ + "\u0000\u1231\u1232\u0003\u03de\u01ef\u0000\u1232\u1233\u0003\u0436\u021b"+ + "\u0000\u1233\u1234\u0003\u0214\u010a\u0000\u1234\u1235\u0003l6\u0000\u1235"+ + "\u0213\u0001\u0000\u0000\u0000\u1236\u1237\u0005\u00a9\u0000\u0000\u1237"+ + "\u123c\u0005\u00dd\u0000\u0000\u1238\u1239\u0005\u0135\u0000\u0000\u1239"+ + "\u123c\u0005\u00dd\u0000\u0000\u123a\u123c\u0001\u0000\u0000\u0000\u123b"+ + "\u1236\u0001\u0000\u0000\u0000\u123b\u1238\u0001\u0000\u0000\u0000\u123b"+ + "\u123a\u0001\u0000\u0000\u0000\u123c\u0215\u0001\u0000\u0000\u0000\u123d"+ + "\u123e\u0005\u00a1\u0000\u0000\u123e\u123f\u0005R\u0000\u0000\u123f\u1240"+ + "\u0003\u0202\u0101\u0000\u1240\u1241\u0003\u020c\u0106\u0000\u1241\u1242"+ + "\u0005v\u0000\u0000\u1242\u1243\u0003\u0218\u010c\u0000\u1243\u12d1\u0001"+ + "\u0000\u0000\u0000\u1244\u1245\u0005\u00a1\u0000\u0000\u1245\u1246\u0005"+ + "R\u0000\u0000\u1246\u1247\u0005.\u0000\u0000\u1247\u1248\u0003\u020c\u0106"+ + "\u0000\u1248\u1249\u0005v\u0000\u0000\u1249\u124a\u0003\u0218\u010c\u0000"+ + "\u124a\u12d1\u0001\u0000\u0000\u0000\u124b\u124c\u0005\u00a1\u0000\u0000"+ + "\u124c\u124d\u0005R\u0000\u0000\u124d\u124e\u0003\u0204\u0102\u0000\u124e"+ + "\u124f\u0003\u053c\u029e\u0000\u124f\u1250\u0005v\u0000\u0000\u1250\u1251"+ + "\u0003\u0218\u010c\u0000\u1251\u12d1\u0001\u0000\u0000\u0000\u1252\u1253"+ + "\u0005\u00a1\u0000\u0000\u1253\u1254\u0005R\u0000\u0000\u1254\u1255\u0005"+ + "\u0163\u0000\u0000\u1255\u1256\u0003\u0460\u0230\u0000\u1256\u1257\u0005"+ + "v\u0000\u0000\u1257\u1258\u0003\u0218\u010c\u0000\u1258\u12d1\u0001\u0000"+ + "\u0000\u0000\u1259\u125a\u0005\u00a1\u0000\u0000\u125a\u125b\u0005R\u0000"+ + "\u0000\u125b\u125c\u0005\u00bf\u0000\u0000\u125c\u125d\u0003\u0460\u0230"+ + "\u0000\u125d\u125e\u0005v\u0000\u0000\u125e\u125f\u0003\u0218\u010c\u0000"+ + "\u125f\u12d1\u0001\u0000\u0000\u0000\u1260\u1261\u0005\u00a1\u0000\u0000"+ + "\u1261\u1262\u0005R\u0000\u0000\u1262\u1263\u0005\u008a\u0000\u0000\u1263"+ + "\u1264\u0003\u028a\u0145\u0000\u1264\u1265\u0005v\u0000\u0000\u1265\u1266"+ + "\u0003\u0218\u010c\u0000\u1266\u12d1\u0001\u0000\u0000\u0000\u1267\u1268"+ + "\u0005\u00a1\u0000\u0000\u1268\u1269\u0005R\u0000\u0000\u1269\u126a\u0005"+ + "\u00d5\u0000\u0000\u126a\u126b\u0003\u0272\u0139\u0000\u126b\u126c\u0005"+ + "v\u0000\u0000\u126c\u126d\u0003\u0218\u010c\u0000\u126d\u12d1\u0001\u0000"+ + "\u0000\u0000\u126e\u126f\u0005\u00a1\u0000\u0000\u126f\u1270\u0005R\u0000"+ + "\u0000\u1270\u1271\u0005\u0111\u0000\u0000\u1271\u1272\u0003\u02b0\u0158"+ + "\u0000\u1272\u1273\u0005v\u0000\u0000\u1273\u1274\u0003\u0218\u010c\u0000"+ + "\u1274\u12d1\u0001\u0000\u0000\u0000\u1275\u1276\u0005\u00a1\u0000\u0000"+ + "\u1276\u1277\u0005R\u0000\u0000\u1277\u1278\u0005/\u0000\u0000\u1278\u1279"+ + "\u0003\u053c\u029e\u0000\u1279\u127a\u0005R\u0000\u0000\u127a\u127b\u0003"+ + "\u020c\u0106\u0000\u127b\u127c\u0005v\u0000\u0000\u127c\u127d\u0003\u0218"+ + "\u010c\u0000\u127d\u12d1\u0001\u0000\u0000\u0000\u127e\u127f\u0005\u00a1"+ + "\u0000\u0000\u127f\u1280\u0005R\u0000\u0000\u1280\u1281\u0005/\u0000\u0000"+ + "\u1281\u1282\u0003\u053c\u029e\u0000\u1282\u1283\u0005R\u0000\u0000\u1283"+ + "\u1284\u0005\u00bf\u0000\u0000\u1284\u1285\u0003\u020c\u0106\u0000\u1285"+ + "\u1286\u0005v\u0000\u0000\u1286\u1287\u0003\u0218\u010c\u0000\u1287\u12d1"+ + "\u0001\u0000\u0000\u0000\u1288\u1289\u0005\u00a1\u0000\u0000\u1289\u128a"+ + "\u0005R\u0000\u0000\u128a\u128b\u0003\u0208\u0104\u0000\u128b\u128c\u0003"+ + "\u053c\u029e\u0000\u128c\u128d\u0005R\u0000\u0000\u128d\u128e\u0003\u020c"+ + "\u0106\u0000\u128e\u128f\u0005v\u0000\u0000\u128f\u1290\u0003\u0218\u010c"+ + "\u0000\u1290\u12d1\u0001\u0000\u0000\u0000\u1291\u1292\u0005\u00a1\u0000"+ + "\u0000\u1292\u1293\u0005R\u0000\u0000\u1293\u1294\u0005\u0123\u0000\u0000"+ + "\u1294\u1295\u0003\u0272\u0139\u0000\u1295\u1296\u0005v\u0000\u0000\u1296"+ + "\u1297\u0003\u0218\u010c\u0000\u1297\u12d1\u0001\u0000\u0000\u0000\u1298"+ + "\u1299\u0005\u00a1\u0000\u0000\u1299\u129a\u0005R\u0000\u0000\u129a\u129b"+ + "\u0005\u01bc\u0000\u0000\u129b\u129c\u0003\u0272\u0139\u0000\u129c\u129d"+ + "\u0005v\u0000\u0000\u129d\u129e\u0003\u0218\u010c\u0000\u129e\u12d1\u0001"+ + "\u0000\u0000\u0000\u129f\u12a0\u0005\u00a1\u0000\u0000\u12a0\u12a1\u0005"+ + "R\u0000\u0000\u12a1\u12a2\u0005\u01bd\u0000\u0000\u12a2\u12a3\u0005@\u0000"+ + "\u0000\u12a3\u12a4\u0003\u0460\u0230\u0000\u12a4\u12a5\u0005\u00f0\u0000"+ + "\u0000\u12a5\u12a6\u0003\u053c\u029e\u0000\u12a6\u12a7\u0005v\u0000\u0000"+ + "\u12a7\u12a8\u0003\u0218\u010c\u0000\u12a8\u12d1\u0001\u0000\u0000\u0000"+ + "\u12a9\u12aa\u0005\u00a1\u0000\u0000\u12aa\u12ab\u0005R\u0000\u0000\u12ab"+ + "\u12ac\u0005\u0111\u0000\u0000\u12ac\u12ad\u0005\u009e\u0000\u0000\u12ad"+ + "\u12ae\u0003\u020c\u0106\u0000\u12ae\u12af\u0005f\u0000\u0000\u12af\u12b0"+ + "\u0003\u053c\u029e\u0000\u12b0\u12b1\u0005v\u0000\u0000\u12b1\u12b2\u0003"+ + "\u0218\u010c\u0000\u12b2\u12d1\u0001\u0000\u0000\u0000\u12b3\u12b4\u0005"+ + "\u00a1\u0000\u0000\u12b4\u12b5\u0005R\u0000\u0000\u12b5\u12b6\u0005\u0111"+ + "\u0000\u0000\u12b6\u12b7\u0005\u00d0\u0000\u0000\u12b7\u12b8\u0003\u020c"+ + "\u0106\u0000\u12b8\u12b9\u0005f\u0000\u0000\u12b9\u12ba\u0003\u053c\u029e"+ + "\u0000\u12ba\u12bb\u0005v\u0000\u0000\u12bb\u12bc\u0003\u0218\u010c\u0000"+ + "\u12bc\u12d1\u0001\u0000\u0000\u0000\u12bd\u12be\u0005\u00a1\u0000\u0000"+ + "\u12be\u12bf\u0005R\u0000\u0000\u12bf\u12c0\u0005\u00f1\u0000\u0000\u12c0"+ + "\u12c1\u0005\u010d\u0000\u0000\u12c1\u12c2\u0003\u0124\u0092\u0000\u12c2"+ + "\u12c3\u0005v\u0000\u0000\u12c3\u12c4\u0003\u0218\u010c\u0000\u12c4\u12d1"+ + "\u0001\u0000\u0000\u0000\u12c5\u12c6\u0005\u00a1\u0000\u0000\u12c6\u12c7"+ + "\u0005R\u0000\u0000\u12c7\u12c8\u0005+\u0000\u0000\u12c8\u12c9\u0005\u0003"+ + "\u0000\u0000\u12c9\u12ca\u0003\u0460\u0230\u0000\u12ca\u12cb\u0005&\u0000"+ + "\u0000\u12cb\u12cc\u0003\u0460\u0230\u0000\u12cc\u12cd\u0005\u0004\u0000"+ + "\u0000\u12cd\u12ce\u0005v\u0000\u0000\u12ce\u12cf\u0003\u0218\u010c\u0000"+ + "\u12cf\u12d1\u0001\u0000\u0000\u0000\u12d0\u123d\u0001\u0000\u0000\u0000"+ + "\u12d0\u1244\u0001\u0000\u0000\u0000\u12d0\u124b\u0001\u0000\u0000\u0000"+ + "\u12d0\u1252\u0001\u0000\u0000\u0000\u12d0\u1259\u0001\u0000\u0000\u0000"+ + "\u12d0\u1260\u0001\u0000\u0000\u0000\u12d0\u1267\u0001\u0000\u0000\u0000"+ + "\u12d0\u126e\u0001\u0000\u0000\u0000\u12d0\u1275\u0001\u0000\u0000\u0000"+ + "\u12d0\u127e\u0001\u0000\u0000\u0000\u12d0\u1288\u0001\u0000\u0000\u0000"+ + "\u12d0\u1291\u0001\u0000\u0000\u0000\u12d0\u1298\u0001\u0000\u0000\u0000"+ + "\u12d0\u129f\u0001\u0000\u0000\u0000\u12d0\u12a9\u0001\u0000\u0000\u0000"+ + "\u12d0\u12b3\u0001\u0000\u0000\u0000\u12d0\u12bd\u0001\u0000\u0000\u0000"+ + "\u12d0\u12c5\u0001\u0000\u0000\u0000\u12d1\u0217\u0001\u0000\u0000\u0000"+ + "\u12d2\u12d5\u0003\u054e\u02a7\u0000\u12d3\u12d5\u0005P\u0000\u0000\u12d4"+ + "\u12d2\u0001\u0000\u0000\u0000\u12d4\u12d3\u0001\u0000\u0000\u0000\u12d5"+ + "\u0219\u0001\u0000\u0000\u0000\u12d6\u12d7\u0005\u0142\u0000\u0000\u12d7"+ + "\u12d8\u0005\u00ef\u0000\u0000\u12d8\u12d9\u0003\u021c\u010e\u0000\u12d9"+ + "\u12da\u0005R\u0000\u0000\u12da\u12db\u0003\u0202\u0101\u0000\u12db\u12dc"+ + "\u0003\u020c\u0106\u0000\u12dc\u12dd\u0005v\u0000\u0000\u12dd\u12de\u0003"+ + "\u021e\u010f\u0000\u12de\u1332\u0001\u0000\u0000\u0000\u12df\u12e0\u0005"+ + "\u0142\u0000\u0000\u12e0\u12e1\u0005\u00ef\u0000\u0000\u12e1\u12e2\u0003"+ + "\u021c\u010e\u0000\u12e2\u12e3\u0005R\u0000\u0000\u12e3\u12e4\u0005.\u0000"+ + "\u0000\u12e4\u12e5\u0003\u020c\u0106\u0000\u12e5\u12e6\u0005v\u0000\u0000"+ + "\u12e6\u12e7\u0003\u021e\u010f\u0000\u12e7\u1332\u0001\u0000\u0000\u0000"+ + "\u12e8\u12e9\u0005\u0142\u0000\u0000\u12e9\u12ea\u0005\u00ef\u0000\u0000"+ + "\u12ea\u12eb\u0003\u021c\u010e\u0000\u12eb\u12ec\u0005R\u0000\u0000\u12ec"+ + "\u12ed\u0003\u0204\u0102\u0000\u12ed\u12ee\u0003\u053c\u029e\u0000\u12ee"+ + "\u12ef\u0005v\u0000\u0000\u12ef\u12f0\u0003\u021e\u010f\u0000\u12f0\u1332"+ + "\u0001\u0000\u0000\u0000\u12f1\u12f2\u0005\u0142\u0000\u0000\u12f2\u12f3"+ + "\u0005\u00ef\u0000\u0000\u12f3\u12f4\u0003\u021c\u010e\u0000\u12f4\u12f5"+ + "\u0005R\u0000\u0000\u12f5\u12f6\u0005\u0163\u0000\u0000\u12f6\u12f7\u0003"+ + "\u0460\u0230\u0000\u12f7\u12f8\u0005v\u0000\u0000\u12f8\u12f9\u0003\u021e"+ + "\u010f\u0000\u12f9\u1332\u0001\u0000\u0000\u0000\u12fa\u12fb\u0005\u0142"+ + "\u0000\u0000\u12fb\u12fc\u0005\u00ef\u0000\u0000\u12fc\u12fd\u0003\u021c"+ + "\u010e\u0000\u12fd\u12fe\u0005R\u0000\u0000\u12fe\u12ff\u0005\u00bf\u0000"+ + "\u0000\u12ff\u1300\u0003\u0460\u0230\u0000\u1300\u1301\u0005v\u0000\u0000"+ + "\u1301\u1302\u0003\u021e\u010f\u0000\u1302\u1332\u0001\u0000\u0000\u0000"+ + "\u1303\u1304\u0005\u0142\u0000\u0000\u1304\u1305\u0005\u00ef\u0000\u0000"+ + "\u1305\u1306\u0003\u021c\u010e\u0000\u1306\u1307\u0005R\u0000\u0000\u1307"+ + "\u1308\u0005\u008a\u0000\u0000\u1308\u1309\u0003\u028a\u0145\u0000\u1309"+ + "\u130a\u0005v\u0000\u0000\u130a\u130b\u0003\u021e\u010f\u0000\u130b\u1332"+ + "\u0001\u0000\u0000\u0000\u130c\u130d\u0005\u0142\u0000\u0000\u130d\u130e"+ + "\u0005\u00ef\u0000\u0000\u130e\u130f\u0003\u021c\u010e\u0000\u130f\u1310"+ + "\u0005R\u0000\u0000\u1310\u1311\u0005\u00d5\u0000\u0000\u1311\u1312\u0003"+ + "\u0272\u0139\u0000\u1312\u1313\u0005v\u0000\u0000\u1313\u1314\u0003\u021e"+ + "\u010f\u0000\u1314\u1332\u0001\u0000\u0000\u0000\u1315\u1316\u0005\u0142"+ + "\u0000\u0000\u1316\u1317\u0005\u00ef\u0000\u0000\u1317\u1318\u0003\u021c"+ + "\u010e\u0000\u1318\u1319\u0005R\u0000\u0000\u1319\u131a\u0005\u00f1\u0000"+ + "\u0000\u131a\u131b\u0005\u010d\u0000\u0000\u131b\u131c\u0003\u0124\u0092"+ + "\u0000\u131c\u131d\u0005v\u0000\u0000\u131d\u131e\u0003\u021e\u010f\u0000"+ + "\u131e\u1332\u0001\u0000\u0000\u0000\u131f\u1320\u0005\u0142\u0000\u0000"+ + "\u1320\u1321\u0005\u00ef\u0000\u0000\u1321\u1322\u0003\u021c\u010e\u0000"+ + "\u1322\u1323\u0005R\u0000\u0000\u1323\u1324\u0005\u0123\u0000\u0000\u1324"+ + "\u1325\u0003\u0272\u0139\u0000\u1325\u1326\u0005v\u0000\u0000\u1326\u1327"+ + "\u0003\u021e\u010f\u0000\u1327\u1332\u0001\u0000\u0000\u0000\u1328\u1329"+ + "\u0005\u0142\u0000\u0000\u1329\u132a\u0005\u00ef\u0000\u0000\u132a\u132b"+ + "\u0003\u021c\u010e\u0000\u132b\u132c\u0005R\u0000\u0000\u132c\u132d\u0005"+ + "\u01bc\u0000\u0000\u132d\u132e\u0003\u0272\u0139\u0000\u132e\u132f\u0005"+ + "v\u0000\u0000\u132f\u1330\u0003\u021e\u010f\u0000\u1330\u1332\u0001\u0000"+ + "\u0000\u0000\u1331\u12d6\u0001\u0000\u0000\u0000\u1331\u12df\u0001\u0000"+ + "\u0000\u0000\u1331\u12e8\u0001\u0000\u0000\u0000\u1331\u12f1\u0001\u0000"+ + "\u0000\u0000\u1331\u12fa\u0001\u0000\u0000\u0000\u1331\u1303\u0001\u0000"+ + "\u0000\u0000\u1331\u130c\u0001\u0000\u0000\u0000\u1331\u1315\u0001\u0000"+ + "\u0000\u0000\u1331\u131f\u0001\u0000\u0000\u0000\u1331\u1328\u0001\u0000"+ + "\u0000\u0000\u1332\u021b\u0001\u0000\u0000\u0000\u1333\u1334\u0005@\u0000"+ + "\u0000\u1334\u1337\u0003H$\u0000\u1335\u1337\u0001\u0000\u0000\u0000\u1336"+ + "\u1333\u0001\u0000\u0000\u0000\u1336\u1335\u0001\u0000\u0000\u0000\u1337"+ + "\u021d\u0001\u0000\u0000\u0000\u1338\u133b\u0003\u054e\u02a7\u0000\u1339"+ + "\u133b\u0005P\u0000\u0000\u133a\u1338\u0001\u0000\u0000\u0000\u133a\u1339"+ + "\u0001\u0000\u0000\u0000\u133b\u021f\u0001\u0000\u0000\u0000\u133c\u133d"+ + "\u0005?\u0000\u0000\u133d\u1341\u0003\u0222\u0111\u0000\u133e\u133f\u0005"+ + "\u0104\u0000\u0000\u133f\u1341\u0003\u0222\u0111\u0000\u1340\u133c\u0001"+ + "\u0000\u0000\u0000\u1340\u133e\u0001\u0000\u0000\u0000\u1341\u0221\u0001"+ + "\u0000\u0000\u0000\u1342\u1385\u0003\u03ba\u01dd\u0000\u1343\u1344\u0003"+ + "\u0224\u0112\u0000\u1344\u1345\u0003\u03ba\u01dd\u0000\u1345\u1385\u0001"+ + "\u0000\u0000\u0000\u1346\u1347\u0005\u0107\u0000\u0000\u1347\u1348\u0003"+ + "\u0226\u0113\u0000\u1348\u1349\u0003\u03ba\u01dd\u0000\u1349\u1385\u0001"+ + "\u0000\u0000\u0000\u134a\u134b\u0005\u0120\u0000\u0000\u134b\u134c\u0003"+ + "\u0226\u0113\u0000\u134c\u134d\u0003\u03ba\u01dd\u0000\u134d\u1385\u0001"+ + "\u0000\u0000\u0000\u134e\u134f\u0005\u00d1\u0000\u0000\u134f\u1350\u0003"+ + "\u0226\u0113\u0000\u1350\u1351\u0003\u03ba\u01dd\u0000\u1351\u1385\u0001"+ + "\u0000\u0000\u0000\u1352\u1353\u0005\u00f2\u0000\u0000\u1353\u1354\u0003"+ + "\u0226\u0113\u0000\u1354\u1355\u0003\u03ba\u01dd\u0000\u1355\u1385\u0001"+ + "\u0000\u0000\u0000\u1356\u1357\u0005\u0084\u0000\u0000\u1357\u1358\u0003"+ + "\u0554\u02aa\u0000\u1358\u1359\u0003\u0226\u0113\u0000\u1359\u135a\u0003"+ + "\u03ba\u01dd\u0000\u135a\u1385\u0001\u0000\u0000\u0000\u135b\u135c\u0005"+ + "\u012e\u0000\u0000\u135c\u135d\u0003\u0554\u02aa\u0000\u135d\u135e\u0003"+ + "\u0226\u0113\u0000\u135e\u135f\u0003\u03ba\u01dd\u0000\u135f\u1385\u0001"+ + "\u0000\u0000\u0000\u1360\u1361\u0003\u0554\u02aa\u0000\u1361\u1362\u0003"+ + "\u0226\u0113\u0000\u1362\u1363\u0003\u03ba\u01dd\u0000\u1363\u1385\u0001"+ + "\u0000\u0000\u0000\u1364\u1365\u0005 \u0000\u0000\u1365\u1366\u0003\u0226"+ + "\u0113\u0000\u1366\u1367\u0003\u03ba\u01dd\u0000\u1367\u1385\u0001\u0000"+ + "\u0000\u0000\u1368\u1369\u0005\u00d4\u0000\u0000\u1369\u136a\u0003\u0226"+ + "\u0113\u0000\u136a\u136b\u0003\u03ba\u01dd\u0000\u136b\u1385\u0001\u0000"+ + "\u0000\u0000\u136c\u136d\u0005\u00d4\u0000\u0000\u136d\u136e\u0003\u0554"+ + "\u02aa\u0000\u136e\u136f\u0003\u0226\u0113\u0000\u136f\u1370\u0003\u03ba"+ + "\u01dd\u0000\u1370\u1385\u0001\u0000\u0000\u0000\u1371\u1372\u0005\u00d4"+ + "\u0000\u0000\u1372\u1373\u0005 \u0000\u0000\u1373\u1374\u0003\u0226\u0113"+ + "\u0000\u1374\u1375\u0003\u03ba\u01dd\u0000\u1375\u1385\u0001\u0000\u0000"+ + "\u0000\u1376\u1377\u0005\u0092\u0000\u0000\u1377\u1378\u0003\u0226\u0113"+ + "\u0000\u1378\u1379\u0003\u03ba\u01dd\u0000\u1379\u1385\u0001\u0000\u0000"+ + "\u0000\u137a\u137b\u0005\u0092\u0000\u0000\u137b\u137c\u0003\u0554\u02aa"+ + "\u0000\u137c\u137d\u0003\u0226\u0113\u0000\u137d\u137e\u0003\u03ba\u01dd"+ + "\u0000\u137e\u1385\u0001\u0000\u0000\u0000\u137f\u1380\u0005\u0092\u0000"+ + "\u0000\u1380\u1381\u0005 \u0000\u0000\u1381\u1382\u0003\u0226\u0113\u0000"+ + "\u1382\u1383\u0003\u03ba\u01dd\u0000\u1383\u1385\u0001\u0000\u0000\u0000"+ + "\u1384\u1342\u0001\u0000\u0000\u0000\u1384\u1343\u0001\u0000\u0000\u0000"+ + "\u1384\u1346\u0001\u0000\u0000\u0000\u1384\u134a\u0001\u0000\u0000\u0000"+ + "\u1384\u134e\u0001\u0000\u0000\u0000\u1384\u1352\u0001\u0000\u0000\u0000"+ + "\u1384\u1356\u0001\u0000\u0000\u0000\u1384\u135b\u0001\u0000\u0000\u0000"+ + "\u1384\u1360\u0001\u0000\u0000\u0000\u1384\u1364\u0001\u0000\u0000\u0000"+ + "\u1384\u1368\u0001\u0000\u0000\u0000\u1384\u136c\u0001\u0000\u0000\u0000"+ + "\u1384\u1371\u0001\u0000\u0000\u0000\u1384\u1376\u0001\u0000\u0000\u0000"+ + "\u1384\u137a\u0001\u0000\u0000\u0000\u1384\u137f\u0001\u0000\u0000\u0000"+ + "\u1385\u0223\u0001\u0000\u0000\u0000\u1386\u1387\u0007\u0018\u0000\u0000"+ + "\u1387\u0225\u0001\u0000\u0000\u0000\u1388\u138b\u0003\u0224\u0112\u0000"+ + "\u1389\u138b\u0001\u0000\u0000\u0000\u138a\u1388\u0001\u0000\u0000\u0000"+ + "\u138a\u1389\u0001\u0000\u0000\u0000\u138b\u0227\u0001\u0000\u0000\u0000"+ + "\u138c\u138d\u0005C\u0000\u0000\u138d\u138e\u0003\u022c\u0116\u0000\u138e"+ + "\u138f\u0005R\u0000\u0000\u138f\u1390\u0003\u0232\u0119\u0000\u1390\u1391"+ + "\u0005`\u0000\u0000\u1391\u1392\u0003\u0234\u011a\u0000\u1392\u1393\u0003"+ + "\u0238\u011c\u0000\u1393\u0229\u0001\u0000\u0000\u0000\u1394\u1395\u0005"+ + "\u0138\u0000\u0000\u1395\u1396\u0003\u022c\u0116\u0000\u1396\u1397\u0005"+ + "R\u0000\u0000\u1397\u1398\u0003\u0232\u0119\u0000\u1398\u1399\u0005B\u0000"+ + "\u0000\u1399\u139a\u0003\u0234\u011a\u0000\u139a\u139b\u0003l6\u0000\u139b"+ + "\u13a8\u0001\u0000\u0000\u0000\u139c\u139d\u0005\u0138\u0000\u0000\u139d"+ + "\u139e\u0005C\u0000\u0000\u139e\u139f\u0005\u0112\u0000\u0000\u139f\u13a0"+ + "\u0005@\u0000\u0000\u13a0\u13a1\u0003\u022c\u0116\u0000\u13a1\u13a2\u0005"+ + "R\u0000\u0000\u13a2\u13a3\u0003\u0232\u0119\u0000\u13a3\u13a4\u0005B\u0000"+ + "\u0000\u13a4\u13a5\u0003\u0234\u011a\u0000\u13a5\u13a6\u0003l6\u0000\u13a6"+ + "\u13a8\u0001\u0000\u0000\u0000\u13a7\u1394\u0001\u0000\u0000\u0000\u13a7"+ + "\u139c\u0001\u0000\u0000\u0000\u13a8\u022b\u0001\u0000\u0000\u0000\u13a9"+ + "\u13b9\u0003\u022e\u0117\u0000\u13aa\u13b9\u0005 \u0000\u0000\u13ab\u13ac"+ + "\u0005 \u0000\u0000\u13ac\u13b9\u0005\u0121\u0000\u0000\u13ad\u13ae\u0005"+ + " \u0000\u0000\u13ae\u13af\u0005\u0003\u0000\u0000\u13af\u13b0\u0003\u00d8"+ + "l\u0000\u13b0\u13b1\u0005\u0004\u0000\u0000\u13b1\u13b9\u0001\u0000\u0000"+ + "\u0000\u13b2\u13b3\u0005 \u0000\u0000\u13b3\u13b4\u0005\u0121\u0000\u0000"+ + "\u13b4\u13b5\u0005\u0003\u0000\u0000\u13b5\u13b6\u0003\u00d8l\u0000\u13b6"+ + "\u13b7\u0005\u0004\u0000\u0000\u13b7\u13b9\u0001\u0000\u0000\u0000\u13b8"+ + "\u13a9\u0001\u0000\u0000\u0000\u13b8\u13aa\u0001\u0000\u0000\u0000\u13b8"+ + "\u13ab\u0001\u0000\u0000\u0000\u13b8\u13ad\u0001\u0000\u0000\u0000\u13b8"+ + "\u13b2\u0001\u0000\u0000\u0000\u13b9\u022d\u0001\u0000\u0000\u0000\u13ba"+ + "\u13bf\u0003\u0230\u0118\u0000\u13bb\u13bc\u0005\u0007\u0000\u0000\u13bc"+ + "\u13be\u0003\u0230\u0118\u0000\u13bd\u13bb\u0001\u0000\u0000\u0000\u13be"+ + "\u13c1\u0001\u0000\u0000\u0000\u13bf\u13bd\u0001\u0000\u0000\u0000\u13bf"+ + "\u13c0\u0001\u0000\u0000\u0000\u13c0\u022f\u0001\u0000\u0000\u0000\u13c1"+ + "\u13bf\u0001\u0000\u0000\u0000\u13c2\u13c3\u0005Z\u0000\u0000\u13c3\u13cc"+ + "\u0003\u00d6k\u0000\u13c4\u13c5\u0005X\u0000\u0000\u13c5\u13cc\u0003\u00d6"+ + "k\u0000\u13c6\u13c7\u00050\u0000\u0000\u13c7\u13cc\u0003\u00d6k\u0000"+ + "\u13c8\u13c9\u0003\u055c\u02ae\u0000\u13c9\u13ca\u0003\u00d6k\u0000\u13ca"+ + "\u13cc\u0001\u0000\u0000\u0000\u13cb\u13c2\u0001\u0000\u0000\u0000\u13cb"+ + "\u13c4\u0001\u0000\u0000\u0000\u13cb\u13c6\u0001\u0000\u0000\u0000\u13cb"+ + "\u13c8\u0001\u0000\u0000\u0000\u13cc\u0231\u0001\u0000\u0000\u0000\u13cd"+ + "\u1408\u0003\u0536\u029b\u0000\u13ce\u13cf\u0005^\u0000\u0000\u13cf\u1408"+ + "\u0003\u0536\u029b\u0000\u13d0\u13d1\u0005\u0143\u0000\u0000\u13d1\u1408"+ + "\u0003\u0536\u029b\u0000\u13d2\u13d3\u0005A\u0000\u0000\u13d3\u13d4\u0005"+ + "\u00b0\u0000\u0000\u13d4\u13d5\u0005\u0178\u0000\u0000\u13d5\u1408\u0003"+ + "\u053a\u029d\u0000\u13d6\u13d7\u0005A\u0000\u0000\u13d7\u13d8\u0005\u0146"+ + "\u0000\u0000\u13d8\u1408\u0003\u053a\u029d\u0000\u13d9\u13da\u0005\u00d5"+ + "\u0000\u0000\u13da\u1408\u0003\u0270\u0138\u0000\u13db\u13dc\u0005\u0123"+ + "\u0000\u0000\u13dc\u1408\u0003\u0270\u0138\u0000\u13dd\u13de\u0005\u01bc"+ + "\u0000\u0000\u13de\u1408\u0003\u0270\u0138\u0000\u13df\u13e0\u0005\u00b1"+ + "\u0000\u0000\u13e0\u1408\u0003\u053a\u029d\u0000\u13e1\u13e2\u0005\u00bf"+ + "\u0000\u0000\u13e2\u1408\u0003\u020a\u0105\u0000\u13e3\u13e4\u0005\u00f0"+ + "\u0000\u0000\u13e4\u1408\u0003\u053a\u029d\u0000\u13e5\u13e6\u0005\u00f1"+ + "\u0000\u0000\u13e6\u13e7\u0005\u010d\u0000\u0000\u13e7\u1408\u0003\u0126"+ + "\u0093\u0000\u13e8\u13e9\u0005\u013e\u0000\u0000\u13e9\u1408\u0003\u053a"+ + "\u029d\u0000\u13ea\u13eb\u0005\u015a\u0000\u0000\u13eb\u1408\u0003\u053a"+ + "\u029d\u0000\u13ec\u13ed\u0005\u0163\u0000\u0000\u13ed\u1408\u0003\u020a"+ + "\u0105\u0000\u13ee\u13ef\u0005 \u0000\u0000\u13ef\u13f0\u0005\u0159\u0000"+ + "\u0000\u13f0\u13f1\u0005F\u0000\u0000\u13f1\u13f2\u0005\u013e\u0000\u0000"+ + "\u13f2\u1408\u0003\u053a\u029d\u0000\u13f3\u13f4\u0005 \u0000\u0000\u13f4"+ + "\u13f5\u0005\u0144\u0000\u0000\u13f5\u13f6\u0005F\u0000\u0000\u13f6\u13f7"+ + "\u0005\u013e\u0000\u0000\u13f7\u1408\u0003\u053a\u029d\u0000\u13f8\u13f9"+ + "\u0005 \u0000\u0000\u13f9\u13fa\u0005\u00d6\u0000\u0000\u13fa\u13fb\u0005"+ + "F\u0000\u0000\u13fb\u13fc\u0005\u013e\u0000\u0000\u13fc\u1408\u0003\u053a"+ + "\u029d\u0000\u13fd\u13fe\u0005 \u0000\u0000\u13fe\u13ff\u0005\u01cb\u0000"+ + "\u0000\u13ff\u1400\u0005F\u0000\u0000\u1400\u1401\u0005\u013e\u0000\u0000"+ + "\u1401\u1408\u0003\u053a\u029d\u0000\u1402\u1403\u0005 \u0000\u0000\u1403"+ + "\u1404\u0005\u01c9\u0000\u0000\u1404\u1405\u0005F\u0000\u0000\u1405\u1406"+ + "\u0005\u013e\u0000\u0000\u1406\u1408\u0003\u053a\u029d\u0000\u1407\u13cd"+ + "\u0001\u0000\u0000\u0000\u1407\u13ce\u0001\u0000\u0000\u0000\u1407\u13d0"+ + "\u0001\u0000\u0000\u0000\u1407\u13d2\u0001\u0000\u0000\u0000\u1407\u13d6"+ + "\u0001\u0000\u0000\u0000\u1407\u13d9\u0001\u0000\u0000\u0000\u1407\u13db"+ + "\u0001\u0000\u0000\u0000\u1407\u13dd\u0001\u0000\u0000\u0000\u1407\u13df"+ + "\u0001\u0000\u0000\u0000\u1407\u13e1\u0001\u0000\u0000\u0000\u1407\u13e3"+ + "\u0001\u0000\u0000\u0000\u1407\u13e5\u0001\u0000\u0000\u0000\u1407\u13e8"+ + "\u0001\u0000\u0000\u0000\u1407\u13ea\u0001\u0000\u0000\u0000\u1407\u13ec"+ + "\u0001\u0000\u0000\u0000\u1407\u13ee\u0001\u0000\u0000\u0000\u1407\u13f3"+ + "\u0001\u0000\u0000\u0000\u1407\u13f8\u0001\u0000\u0000\u0000\u1407\u13fd"+ + "\u0001\u0000\u0000\u0000\u1407\u1402\u0001\u0000\u0000\u0000\u1408\u0233"+ + "\u0001\u0000\u0000\u0000\u1409\u140e\u0003\u0236\u011b\u0000\u140a\u140b"+ + "\u0005\u0007\u0000\u0000\u140b\u140d\u0003\u0236\u011b\u0000\u140c\u140a"+ + "\u0001\u0000\u0000\u0000\u140d\u1410\u0001\u0000\u0000\u0000\u140e\u140c"+ + "\u0001\u0000\u0000\u0000\u140e\u140f\u0001\u0000\u0000\u0000\u140f\u0235"+ + "\u0001\u0000\u0000\u0000\u1410\u140e\u0001\u0000\u0000\u0000\u1411\u1415"+ + "\u0003\u0558\u02ac\u0000\u1412\u1413\u0005D\u0000\u0000\u1413\u1415\u0003"+ + "\u0558\u02ac\u0000\u1414\u1411\u0001\u0000\u0000\u0000\u1414\u1412\u0001"+ + "\u0000\u0000\u0000\u1415\u0237\u0001\u0000\u0000\u0000\u1416\u1417\u0005"+ + "k\u0000\u0000\u1417\u1418\u0005C\u0000\u0000\u1418\u141b\u0005\u0112\u0000"+ + "\u0000\u1419\u141b\u0001\u0000\u0000\u0000\u141a\u1416\u0001\u0000\u0000"+ + "\u0000\u141a\u1419\u0001\u0000\u0000\u0000\u141b\u0239\u0001\u0000\u0000"+ + "\u0000\u141c\u141d\u0005C\u0000\u0000\u141d\u141e\u0003\u022e\u0117\u0000"+ + "\u141e\u141f\u0005`\u0000\u0000\u141f\u1420\u0003\u055a\u02ad\u0000\u1420"+ + "\u1421\u0003\u023e\u011f\u0000\u1421\u1422\u0003\u0240\u0120\u0000\u1422"+ + "\u023b\u0001\u0000\u0000\u0000\u1423\u1424\u0005\u0138\u0000\u0000\u1424"+ + "\u1425\u0003\u022e\u0117\u0000\u1425\u1426\u0005B\u0000\u0000\u1426\u1427"+ + "\u0003\u055a\u02ad\u0000\u1427\u1428\u0003\u0240\u0120\u0000\u1428\u1429"+ + "\u0003l6\u0000\u1429\u1435\u0001\u0000\u0000\u0000\u142a\u142b\u0005\u0138"+ + "\u0000\u0000\u142b\u142c\u0005\u0088\u0000\u0000\u142c\u142d\u0005\u0112"+ + "\u0000\u0000\u142d\u142e\u0005@\u0000\u0000\u142e\u142f\u0003\u022e\u0117"+ + "\u0000\u142f\u1430\u0005B\u0000\u0000\u1430\u1431\u0003\u055a\u02ad\u0000"+ + "\u1431\u1432\u0003\u0240\u0120\u0000\u1432\u1433\u0003l6\u0000\u1433\u1435"+ + "\u0001\u0000\u0000\u0000\u1434\u1423\u0001\u0000\u0000\u0000\u1434\u142a"+ + "\u0001\u0000\u0000\u0000\u1435\u023d\u0001\u0000\u0000\u0000\u1436\u1437"+ + "\u0005k\u0000\u0000\u1437\u1438\u0005\u0088\u0000\u0000\u1438\u143b\u0005"+ + "\u0112\u0000\u0000\u1439\u143b\u0001\u0000\u0000\u0000\u143a\u1436\u0001"+ + "\u0000\u0000\u0000\u143a\u1439\u0001\u0000\u0000\u0000\u143b\u023f\u0001"+ + "\u0000\u0000\u0000\u143c\u143d\u0005\u00d8\u0000\u0000\u143d\u143e\u0005"+ + "\u0095\u0000\u0000\u143e\u1441\u0003\u0558\u02ac\u0000\u143f\u1441\u0001"+ + "\u0000\u0000\u0000\u1440\u143c\u0001\u0000\u0000\u0000\u1440\u143f\u0001"+ + "\u0000\u0000\u0000\u1441\u0241\u0001\u0000\u0000\u0000\u1442\u1443\u0005"+ + "\u008c\u0000\u0000\u1443\u1444\u00057\u0000\u0000\u1444\u1445\u0005\u0121"+ + "\u0000\u0000\u1445\u1446\u0003\u0244\u0122\u0000\u1446\u1447\u0003\u0248"+ + "\u0124\u0000\u1447\u0243\u0001\u0000\u0000\u0000\u1448\u144a\u0003\u0246"+ + "\u0123\u0000\u1449\u1448\u0001\u0000\u0000\u0000\u144a\u144d\u0001\u0000"+ + "\u0000\u0000\u144b\u1449\u0001\u0000\u0000\u0000\u144b\u144c\u0001\u0000"+ + "\u0000\u0000\u144c\u0245\u0001\u0000\u0000\u0000\u144d\u144b\u0001\u0000"+ + "\u0000\u0000\u144e\u144f\u0005F\u0000\u0000\u144f\u1450\u0005\u013e\u0000"+ + "\u0000\u1450\u1458\u0003\u053a\u029d\u0000\u1451\u1452\u0005@\u0000\u0000"+ + "\u1452\u1453\u0005\u0139\u0000\u0000\u1453\u1458\u0003\u055a\u02ad\u0000"+ + "\u1454\u1455\u0005@\u0000\u0000\u1455\u1456\u0005e\u0000\u0000\u1456\u1458"+ + "\u0003\u055a\u02ad\u0000\u1457\u144e\u0001\u0000\u0000\u0000\u1457\u1451"+ + "\u0001\u0000\u0000\u0000\u1457\u1454\u0001\u0000\u0000\u0000\u1458\u0247"+ + "\u0001\u0000\u0000\u0000\u1459\u145a\u0005C\u0000\u0000\u145a\u145b\u0003"+ + "\u022c\u0116\u0000\u145b\u145c\u0005R\u0000\u0000\u145c\u145d\u0003\u024a"+ + "\u0125\u0000\u145d\u145e\u0005`\u0000\u0000\u145e\u145f\u0003\u0234\u011a"+ + "\u0000\u145f\u1460\u0003\u0238\u011c\u0000\u1460\u1475\u0001\u0000\u0000"+ + "\u0000\u1461\u1462\u0005\u0138\u0000\u0000\u1462\u1463\u0003\u022c\u0116"+ + "\u0000\u1463\u1464\u0005R\u0000\u0000\u1464\u1465\u0003\u024a\u0125\u0000"+ + "\u1465\u1466\u0005B\u0000\u0000\u1466\u1467\u0003\u0234\u011a\u0000\u1467"+ + "\u1468\u0003l6\u0000\u1468\u1475\u0001\u0000\u0000\u0000\u1469\u146a\u0005"+ + "\u0138\u0000\u0000\u146a\u146b\u0005C\u0000\u0000\u146b\u146c\u0005\u0112"+ + "\u0000\u0000\u146c\u146d\u0005@\u0000\u0000\u146d\u146e\u0003\u022c\u0116"+ + "\u0000\u146e\u146f\u0005R\u0000\u0000\u146f\u1470\u0003\u024a\u0125\u0000"+ + "\u1470\u1471\u0005B\u0000\u0000\u1471\u1472\u0003\u0234\u011a\u0000\u1472"+ + "\u1473\u0003l6\u0000\u1473\u1475\u0001\u0000\u0000\u0000\u1474\u1459\u0001"+ + "\u0000\u0000\u0000\u1474\u1461\u0001\u0000\u0000\u0000\u1474\u1469\u0001"+ + "\u0000\u0000\u0000\u1475\u0249\u0001\u0000\u0000\u0000\u1476\u1477\u0007"+ + "\u0019\u0000\u0000\u1477\u024b\u0001\u0000\u0000\u0000\u1478\u1479\u0005"+ + "0\u0000\u0000\u1479\u147a\u0003\u024e\u0127\u0000\u147a\u147b\u0005\u00e4"+ + "\u0000\u0000\u147b\u147c\u0003\u0250\u0128\u0000\u147c\u147d\u0003\u0252"+ + "\u0129\u0000\u147d\u147e\u0005R\u0000\u0000\u147e\u147f\u0003\u0434\u021a"+ + "\u0000\u147f\u1480\u0003\u0254\u012a\u0000\u1480\u1481\u0005\u0003\u0000"+ + "\u0000\u1481\u1482\u0003\u0256\u012b\u0000\u1482\u1483\u0005\u0004\u0000"+ + "\u0000\u1483\u1484\u0003\u025c\u012e\u0000\u1484\u1485\u0003v;\u0000\u1485"+ + "\u1486\u0003\u00fe\u007f\u0000\u1486\u1487\u0003\u0448\u0224\u0000\u1487"+ + "\u149c\u0001\u0000\u0000\u0000\u1488\u1489\u00050\u0000\u0000\u1489\u148a"+ + "\u0003\u024e\u0127\u0000\u148a\u148b\u0005\u00e4\u0000\u0000\u148b\u148c"+ + "\u0003\u0250\u0128\u0000\u148c\u148d\u0005\u00de\u0000\u0000\u148d\u148e"+ + "\u0005O\u0000\u0000\u148e\u148f\u0005\u0187\u0000\u0000\u148f\u1490\u0003"+ + "\u053c\u029e\u0000\u1490\u1491\u0005R\u0000\u0000\u1491\u1492\u0003\u0434"+ + "\u021a\u0000\u1492\u1493\u0003\u0254\u012a\u0000\u1493\u1494\u0005\u0003"+ + "\u0000\u0000\u1494\u1495\u0003\u0256\u012b\u0000\u1495\u1496\u0005\u0004"+ + "\u0000\u0000\u1496\u1497\u0003\u025c\u012e\u0000\u1497\u1498\u0003v;\u0000"+ + "\u1498\u1499\u0003\u00fe\u007f\u0000\u1499\u149a\u0003\u0448\u0224\u0000"+ + "\u149a\u149c\u0001\u0000\u0000\u0000\u149b\u1478\u0001\u0000\u0000\u0000"+ + "\u149b\u1488\u0001\u0000\u0000\u0000\u149c\u024d\u0001\u0000\u0000\u0000"+ + "\u149d\u14a0\u0005d\u0000\u0000\u149e\u14a0\u0001\u0000\u0000\u0000\u149f"+ + "\u149d\u0001\u0000\u0000\u0000\u149f\u149e\u0001\u0000\u0000\u0000\u14a0"+ + "\u024f\u0001\u0000\u0000\u0000\u14a1\u14a4\u0005o\u0000\u0000\u14a2\u14a4"+ + "\u0001\u0000\u0000\u0000\u14a3\u14a1\u0001\u0000\u0000\u0000\u14a3\u14a2"+ + "\u0001\u0000\u0000\u0000\u14a4\u0251\u0001\u0000\u0000\u0000\u14a5\u14a8"+ + "\u0003\u053c\u029e\u0000\u14a6\u14a8\u0001\u0000\u0000\u0000\u14a7\u14a5"+ + "\u0001\u0000\u0000\u0000\u14a7\u14a6\u0001\u0000\u0000\u0000\u14a8\u0253"+ + "\u0001\u0000\u0000\u0000\u14a9\u14aa\u0005f\u0000\u0000\u14aa\u14ad\u0003"+ + "\u053c\u029e\u0000\u14ab\u14ad\u0001\u0000\u0000\u0000\u14ac\u14a9\u0001"+ + "\u0000\u0000\u0000\u14ac\u14ab\u0001\u0000\u0000\u0000\u14ad\u0255\u0001"+ + "\u0000\u0000\u0000\u14ae\u14b3\u0003\u025a\u012d\u0000\u14af\u14b0\u0005"+ + "\u0007\u0000\u0000\u14b0\u14b2\u0003\u025a\u012d\u0000\u14b1\u14af\u0001"+ + "\u0000\u0000\u0000\u14b2\u14b5\u0001\u0000\u0000\u0000\u14b3\u14b1\u0001"+ + "\u0000\u0000\u0000\u14b3\u14b4\u0001\u0000\u0000\u0000\u14b4\u0257\u0001"+ + "\u0000\u0000\u0000\u14b5\u14b3\u0001\u0000\u0000\u0000\u14b6\u14b7\u0003"+ + "\u0260\u0130\u0000\u14b7\u14b8\u0003\u0262\u0131\u0000\u14b8\u14b9\u0003"+ + "\u0264\u0132\u0000\u14b9\u14ba\u0003\u0266\u0133\u0000\u14ba\u14c2\u0001"+ + "\u0000\u0000\u0000\u14bb\u14bc\u0003\u0260\u0130\u0000\u14bc\u14bd\u0003"+ + "\u020c\u0106\u0000\u14bd\u14be\u0003t:\u0000\u14be\u14bf\u0003\u0264\u0132"+ + "\u0000\u14bf\u14c0\u0003\u0266\u0133\u0000\u14c0\u14c2\u0001\u0000\u0000"+ + "\u0000\u14c1\u14b6\u0001\u0000\u0000\u0000\u14c1\u14bb\u0001\u0000\u0000"+ + "\u0000\u14c2\u0259\u0001\u0000\u0000\u0000\u14c3\u14c4\u0003\u055c\u02ae"+ + "\u0000\u14c4\u14c5\u0003\u0258\u012c\u0000\u14c5\u14cf\u0001\u0000\u0000"+ + "\u0000\u14c6\u14c7\u0003\u04be\u025f\u0000\u14c7\u14c8\u0003\u0258\u012c"+ + "\u0000\u14c8\u14cf\u0001\u0000\u0000\u0000\u14c9\u14ca\u0005\u0003\u0000"+ + "\u0000\u14ca\u14cb\u0003\u048c\u0246\u0000\u14cb\u14cc\u0005\u0004\u0000"+ + "\u0000\u14cc\u14cd\u0003\u0258\u012c\u0000\u14cd\u14cf\u0001\u0000\u0000"+ + "\u0000\u14ce\u14c3\u0001\u0000\u0000\u0000\u14ce\u14c6\u0001\u0000\u0000"+ + "\u0000\u14ce\u14c9\u0001\u0000\u0000\u0000\u14cf\u025b\u0001\u0000\u0000"+ + "\u0000\u14d0\u14d1\u0005\u01bb\u0000\u0000\u14d1\u14d2\u0005\u0003\u0000"+ + "\u0000\u14d2\u14d3\u0003\u025e\u012f\u0000\u14d3\u14d4\u0005\u0004\u0000"+ + "\u0000\u14d4\u14d7\u0001\u0000\u0000\u0000\u14d5\u14d7\u0001\u0000\u0000"+ + "\u0000\u14d6\u14d0\u0001\u0000\u0000\u0000\u14d6\u14d5\u0001\u0000\u0000"+ + "\u0000\u14d7\u025d\u0001\u0000\u0000\u0000\u14d8\u14dd\u0003\u025a\u012d"+ + "\u0000\u14d9\u14da\u0005\u0007\u0000\u0000\u14da\u14dc\u0003\u025a\u012d"+ + "\u0000\u14db\u14d9\u0001\u0000\u0000\u0000\u14dc\u14df\u0001\u0000\u0000"+ + "\u0000\u14dd\u14db\u0001\u0000\u0000\u0000\u14dd\u14de\u0001\u0000\u0000"+ + "\u0000\u14de\u025f\u0001\u0000\u0000\u0000\u14df\u14dd\u0001\u0000\u0000"+ + "\u0000\u14e0\u14e1\u0005-\u0000\u0000\u14e1\u14e4\u0003\u020c\u0106\u0000"+ + "\u14e2\u14e4\u0001\u0000\u0000\u0000\u14e3\u14e0\u0001\u0000\u0000\u0000"+ + "\u14e3\u14e2\u0001\u0000\u0000\u0000\u14e4\u0261\u0001\u0000\u0000\u0000"+ + "\u14e5\u14e8\u0003\u020c\u0106\u0000\u14e6\u14e8\u0001\u0000\u0000\u0000"+ + "\u14e7\u14e5\u0001\u0000\u0000\u0000\u14e7\u14e6\u0001\u0000\u0000\u0000"+ + "\u14e8\u0263\u0001\u0000\u0000\u0000\u14e9\u14ed\u0005\'\u0000\u0000\u14ea"+ + "\u14ed\u00059\u0000\u0000\u14eb\u14ed\u0001\u0000\u0000\u0000\u14ec\u14e9"+ + "\u0001\u0000\u0000\u0000\u14ec\u14ea\u0001\u0000\u0000\u0000\u14ec\u14eb"+ + "\u0001\u0000\u0000\u0000\u14ed\u0265\u0001\u0000\u0000\u0000\u14ee\u14ef"+ + "\u0005\u010c\u0000\u0000\u14ef\u14f4\u0005\u00d1\u0000\u0000\u14f0\u14f1"+ + "\u0005\u010c\u0000\u0000\u14f1\u14f4\u0005\u00f2\u0000\u0000\u14f2\u14f4"+ + "\u0001\u0000\u0000\u0000\u14f3\u14ee\u0001\u0000\u0000\u0000\u14f3\u14f0"+ + "\u0001\u0000\u0000\u0000\u14f3\u14f2\u0001\u0000\u0000\u0000\u14f4\u0267"+ + "\u0001\u0000\u0000\u0000\u14f5\u14f6\u00050\u0000\u0000\u14f6\u14f7\u0003"+ + "\u026a\u0135\u0000\u14f7\u14f8\u0007\u0016\u0000\u0000\u14f8\u14f9\u0003"+ + "\u0542\u02a1\u0000\u14f9\u1503\u0003\u0274\u013a\u0000\u14fa\u1501\u0005"+ + "\u0137\u0000\u0000\u14fb\u1502\u0003\u027e\u013f\u0000\u14fc\u14fd\u0005"+ + "^\u0000\u0000\u14fd\u14fe\u0005\u0003\u0000\u0000\u14fe\u14ff\u0003\u029c"+ + "\u014e\u0000\u14ff\u1500\u0005\u0004\u0000\u0000\u1500\u1502\u0001\u0000"+ + "\u0000\u0000\u1501\u14fb\u0001\u0000\u0000\u0000\u1501\u14fc\u0001\u0000"+ + "\u0000\u0000\u1502\u1504\u0001\u0000\u0000\u0000\u1503\u14fa\u0001\u0000"+ + "\u0000\u0000\u1503\u1504\u0001\u0000\u0000\u0000\u1504\u1505\u0001\u0000"+ + "\u0000\u0000\u1505\u1506\u0003\u028e\u0147\u0000\u1506\u0269\u0001\u0000"+ + "\u0000\u0000\u1507\u1508\u0005T\u0000\u0000\u1508\u150b\u0005\u0132\u0000"+ + "\u0000\u1509\u150b\u0001\u0000\u0000\u0000\u150a\u1507\u0001\u0000\u0000"+ + "\u0000\u150a\u1509\u0001\u0000\u0000\u0000\u150b\u026b\u0001\u0000\u0000"+ + "\u0000\u150c\u150e\u0005\u0003\u0000\u0000\u150d\u150f\u0003\u026e\u0137"+ + "\u0000\u150e\u150d\u0001\u0000\u0000\u0000\u150e\u150f\u0001\u0000\u0000"+ + "\u0000\u150f\u1510\u0001\u0000\u0000\u0000\u1510\u1511\u0005\u0004\u0000"+ + "\u0000\u1511\u026d\u0001\u0000\u0000\u0000\u1512\u1517\u0003\u0278\u013c"+ + "\u0000\u1513\u1514\u0005\u0007\u0000\u0000\u1514\u1516\u0003\u0278\u013c"+ + "\u0000\u1515\u1513\u0001\u0000\u0000\u0000\u1516\u1519\u0001\u0000\u0000"+ + "\u0000\u1517\u1515\u0001\u0000\u0000\u0000\u1517\u1518\u0001\u0000\u0000"+ + "\u0000\u1518\u026f\u0001\u0000\u0000\u0000\u1519\u1517\u0001\u0000\u0000"+ + "\u0000\u151a\u151f\u0003\u0272\u0139\u0000\u151b\u151c\u0005\u0007\u0000"+ + "\u0000\u151c\u151e\u0003\u0272\u0139\u0000\u151d\u151b\u0001\u0000\u0000"+ + "\u0000\u151e\u1521\u0001\u0000\u0000\u0000\u151f\u151d\u0001\u0000\u0000"+ + "\u0000\u151f\u1520\u0001\u0000\u0000\u0000\u1520\u0271\u0001\u0000\u0000"+ + "\u0000\u1521\u151f\u0001\u0000\u0000\u0000\u1522\u1523\u0003\u0542\u02a1"+ + "\u0000\u1523\u1524\u0003\u026c\u0136\u0000\u1524\u152b\u0001\u0000\u0000"+ + "\u0000\u1525\u152b\u0003\u056e\u02b7\u0000\u1526\u1528\u0003\u055c\u02ae"+ + "\u0000\u1527\u1529\u0003\u052c\u0296\u0000\u1528\u1527\u0001\u0000\u0000"+ + "\u0000\u1528\u1529\u0001\u0000\u0000\u0000\u1529\u152b\u0001\u0000\u0000"+ + "\u0000\u152a\u1522\u0001\u0000\u0000\u0000\u152a\u1525\u0001\u0000\u0000"+ + "\u0000\u152a\u1526\u0001\u0000\u0000\u0000\u152b\u0273\u0001\u0000\u0000"+ + "\u0000\u152c\u152e\u0005\u0003\u0000\u0000\u152d\u152f\u0003\u0276\u013b"+ + "\u0000\u152e\u152d\u0001\u0000\u0000\u0000\u152e\u152f\u0001\u0000\u0000"+ + "\u0000\u152f\u1530\u0001\u0000\u0000\u0000\u1530\u1531\u0005\u0004\u0000"+ + "\u0000\u1531\u0275\u0001\u0000\u0000\u0000\u1532\u1537\u0003\u0282\u0141"+ + "\u0000\u1533\u1534\u0005\u0007\u0000\u0000\u1534\u1536\u0003\u0282\u0141"+ + "\u0000\u1535\u1533\u0001\u0000\u0000\u0000\u1536\u1539\u0001\u0000\u0000"+ + "\u0000\u1537\u1535\u0001\u0000\u0000\u0000\u1537\u1538\u0001\u0000\u0000"+ + "\u0000\u1538\u0277\u0001\u0000\u0000\u0000\u1539\u1537\u0001\u0000\u0000"+ + "\u0000\u153a\u153c\u0003\u027a\u013d\u0000\u153b\u153d\u0003\u027c\u013e"+ + "\u0000\u153c\u153b\u0001\u0000\u0000\u0000\u153c\u153d\u0001\u0000\u0000"+ + "\u0000\u153d\u153e\u0001\u0000\u0000\u0000\u153e\u153f\u0003\u0280\u0140"+ + "\u0000\u153f\u1548\u0001\u0000\u0000\u0000\u1540\u1542\u0003\u027c\u013e"+ + "\u0000\u1541\u1543\u0003\u027a\u013d\u0000\u1542\u1541\u0001\u0000\u0000"+ + "\u0000\u1542\u1543\u0001\u0000\u0000\u0000\u1543\u1544\u0001\u0000\u0000"+ + "\u0000\u1544\u1545\u0003\u0280\u0140\u0000\u1545\u1548\u0001\u0000\u0000"+ + "\u0000\u1546\u1548\u0003\u0280\u0140\u0000\u1547\u153a\u0001\u0000\u0000"+ + "\u0000\u1547\u1540\u0001\u0000\u0000\u0000\u1547\u1546\u0001\u0000\u0000"+ + "\u0000\u1548\u0279\u0001\u0000\u0000\u0000\u1549\u154b\u0005F\u0000\u0000"+ + "\u154a\u154c\u0005\u01c7\u0000\u0000\u154b\u154a\u0001\u0000\u0000\u0000"+ + "\u154b\u154c\u0001\u0000\u0000\u0000\u154c\u1551\u0001\u0000\u0000\u0000"+ + "\u154d\u1551\u0005\u01c7\u0000\u0000\u154e\u1551\u0005\u018b\u0000\u0000"+ + "\u154f\u1551\u0005g\u0000\u0000\u1550\u1549\u0001\u0000\u0000\u0000\u1550"+ + "\u154d\u0001\u0000\u0000\u0000\u1550\u154e\u0001\u0000\u0000\u0000\u1550"+ + "\u154f\u0001\u0000\u0000\u0000\u1551\u027b\u0001\u0000\u0000\u0000\u1552"+ + "\u1557\u0003\u0560\u02b0\u0000\u1553\u1557\u0003\u0572\u02b9\u0000\u1554"+ + "\u1557\u0005y\u0000\u0000\u1555\u1557\u0005\u0080\u0000\u0000\u1556\u1552"+ + "\u0001\u0000\u0000\u0000\u1556\u1553\u0001\u0000\u0000\u0000\u1556\u1554"+ + "\u0001\u0000\u0000\u0000\u1556\u1555\u0001\u0000\u0000\u0000\u1557\u027d"+ + "\u0001\u0000\u0000\u0000\u1558\u1559\u0003\u0280\u0140\u0000\u1559\u027f"+ + "\u0001\u0000\u0000\u0000\u155a\u1569\u0003\u0460\u0230\u0000\u155b\u155d"+ + "\u0005\u019a\u0000\u0000\u155c\u155b\u0001\u0000\u0000\u0000\u155c\u155d"+ + "\u0001\u0000\u0000\u0000\u155d\u1562\u0001\u0000\u0000\u0000\u155e\u1563"+ + "\u0003\u0572\u02b9\u0000\u155f\u1563\u0003\u0560\u02b0\u0000\u1560\u1563"+ + "\u0005y\u0000\u0000\u1561\u1563\u0005\u0080\u0000\u0000\u1562\u155e\u0001"+ + "\u0000\u0000\u0000\u1562\u155f\u0001\u0000\u0000\u0000\u1562\u1560\u0001"+ + "\u0000\u0000\u0000\u1562\u1561\u0001\u0000\u0000\u0000\u1563\u1564\u0001"+ + "\u0000\u0000\u0000\u1564\u1565\u0003\u020e\u0107\u0000\u1565\u1566\u0005"+ + "\u001d\u0000\u0000\u1566\u1567\u0005\u0163\u0000\u0000\u1567\u1569\u0001"+ + "\u0000\u0000\u0000\u1568\u155a\u0001\u0000\u0000\u0000\u1568\u155c\u0001"+ + "\u0000\u0000\u0000\u1569\u0281\u0001\u0000\u0000\u0000\u156a\u156d\u0003"+ + "\u0278\u013c\u0000\u156b\u156c\u0007\u001a\u0000\u0000\u156c\u156e\u0003"+ + "\u048c\u0246\u0000\u156d\u156b\u0001\u0000\u0000\u0000\u156d\u156e\u0001"+ + "\u0000\u0000\u0000\u156e\u0283\u0001\u0000\u0000\u0000\u156f\u1570\u0003"+ + "\u0278\u013c\u0000\u1570\u0285\u0001\u0000\u0000\u0000\u1571\u157c\u0005"+ + "\u0003\u0000\u0000\u1572\u157d\u0005\u000b\u0000\u0000\u1573\u157d\u0003"+ + "\u0288\u0144\u0000\u1574\u1575\u0005U\u0000\u0000\u1575\u1576\u0005\u0095"+ + "\u0000\u0000\u1576\u157d\u0003\u0288\u0144\u0000\u1577\u1578\u0003\u0288"+ + "\u0144\u0000\u1578\u1579\u0005U\u0000\u0000\u1579\u157a\u0005\u0095\u0000"+ + "\u0000\u157a\u157b\u0003\u0288\u0144\u0000\u157b\u157d\u0001\u0000\u0000"+ + "\u0000\u157c\u1572\u0001\u0000\u0000\u0000\u157c\u1573\u0001\u0000\u0000"+ + "\u0000\u157c\u1574\u0001\u0000\u0000\u0000\u157c\u1577\u0001\u0000\u0000"+ + "\u0000\u157d\u157e\u0001\u0000\u0000\u0000\u157e\u157f\u0005\u0004\u0000"+ + "\u0000\u157f\u0287\u0001\u0000\u0000\u0000\u1580\u1585\u0003\u0284\u0142"+ + "\u0000\u1581\u1582\u0005\u0007\u0000\u0000\u1582\u1584\u0003\u0284\u0142"+ + "\u0000\u1583\u1581\u0001\u0000\u0000\u0000\u1584\u1587\u0001\u0000\u0000"+ + "\u0000\u1585\u1583\u0001\u0000\u0000\u0000\u1585\u1586\u0001\u0000\u0000"+ + "\u0000\u1586\u0289\u0001\u0000\u0000\u0000\u1587\u1585\u0001\u0000\u0000"+ + "\u0000\u1588\u1589\u0003\u0542\u02a1\u0000\u1589\u158a\u0003\u0286\u0143"+ + "\u0000\u158a\u028b\u0001\u0000\u0000\u0000\u158b\u1590\u0003\u028a\u0145"+ + "\u0000\u158c\u158d\u0005\u0007\u0000\u0000\u158d\u158f\u0003\u028a\u0145"+ + "\u0000\u158e\u158c\u0001\u0000\u0000\u0000\u158f\u1592\u0001\u0000\u0000"+ + "\u0000\u1590\u158e\u0001\u0000\u0000\u0000\u1590\u1591\u0001\u0000\u0000"+ + "\u0000\u1591\u028d\u0001\u0000\u0000\u0000\u1592\u1590\u0001\u0000\u0000"+ + "\u0000\u1593\u1595\u0003\u0292\u0149\u0000\u1594\u1593\u0001\u0000\u0000"+ + "\u0000\u1595\u1596\u0001\u0000\u0000\u0000\u1596\u1594\u0001\u0000\u0000"+ + "\u0000\u1596\u1597\u0001\u0000\u0000\u0000\u1597\u1598\u0001\u0000\u0000"+ + "\u0000\u1598\u1599\u0006\u0147\uffff\uffff\u0000\u1599\u028f\u0001\u0000"+ + "\u0000\u0000\u159a\u159b\u0005\u0097\u0000\u0000\u159b\u159c\u0005R\u0000"+ + "\u0000\u159c\u159d\u0005P\u0000\u0000\u159d\u15be\u0005\u01cc\u0000\u0000"+ + "\u159e\u159f\u0005\u0137\u0000\u0000\u159f\u15a0\u0005P\u0000\u0000\u15a0"+ + "\u15a1\u0005R\u0000\u0000\u15a1\u15a2\u0005P\u0000\u0000\u15a2\u15be\u0005"+ + "\u01cc\u0000\u0000\u15a3\u15be\u0005\u0155\u0000\u0000\u15a4\u15be\u0005"+ + "\u00e0\u0000\u0000\u15a5\u15be\u0005\u014d\u0000\u0000\u15a6\u15be\u0005"+ + "\u0174\u0000\u0000\u15a7\u15a8\u0005\u00cf\u0000\u0000\u15a8\u15a9\u0005"+ + "\u0142\u0000\u0000\u15a9\u15be\u0005\u00b7\u0000\u0000\u15aa\u15ab\u0005"+ + "\u00cf\u0000\u0000\u15ab\u15ac\u0005\u0142\u0000\u0000\u15ac\u15be\u0005"+ + "\u00ec\u0000\u0000\u15ad\u15ae\u0005\u0142\u0000\u0000\u15ae\u15be\u0005"+ + "\u00b7\u0000\u0000\u15af\u15b0\u0005\u0142\u0000\u0000\u15b0\u15be\u0005"+ + "\u00ec\u0000\u0000\u15b1\u15be\u0005\u00f3\u0000\u0000\u15b2\u15b3\u0005"+ + "O\u0000\u0000\u15b3\u15be\u0005\u00f3\u0000\u0000\u15b4\u15b5\u0005\u00ac"+ + "\u0000\u0000\u15b5\u15be\u0003\u0124\u0092\u0000\u15b6\u15b7\u0005\u013b"+ + "\u0000\u0000\u15b7\u15be\u0003\u0124\u0092\u0000\u15b8\u15b9\u0005\u01cd"+ + "\u0000\u0000\u15b9\u15be\u0003\u020c\u0106\u0000\u15ba\u15be\u0003R)\u0000"+ + "\u15bb\u15bc\u0005\u01ce\u0000\u0000\u15bc\u15be\u0003\u055c\u02ae\u0000"+ + "\u15bd\u159a\u0001\u0000\u0000\u0000\u15bd\u159e\u0001\u0000\u0000\u0000"+ + "\u15bd\u15a3\u0001\u0000\u0000\u0000\u15bd\u15a4\u0001\u0000\u0000\u0000"+ + "\u15bd\u15a5\u0001\u0000\u0000\u0000\u15bd\u15a6\u0001\u0000\u0000\u0000"+ + "\u15bd\u15a7\u0001\u0000\u0000\u0000\u15bd\u15aa\u0001\u0000\u0000\u0000"+ + "\u15bd\u15ad\u0001\u0000\u0000\u0000\u15bd\u15af\u0001\u0000\u0000\u0000"+ + "\u15bd\u15b1\u0001\u0000\u0000\u0000\u15bd\u15b2\u0001\u0000\u0000\u0000"+ + "\u15bd\u15b4\u0001\u0000\u0000\u0000\u15bd\u15b6\u0001\u0000\u0000\u0000"+ + "\u15bd\u15b8\u0001\u0000\u0000\u0000\u15bd\u15ba\u0001\u0000\u0000\u0000"+ + "\u15bd\u15bb\u0001\u0000\u0000\u0000\u15be\u0291\u0001\u0000\u0000\u0000"+ + "\u15bf\u15c0\u0005&\u0000\u0000\u15c0\u15c8\u0003\u0294\u014a\u0000\u15c1"+ + "\u15c2\u0005\u00f0\u0000\u0000\u15c2\u15c8\u0003H$\u0000\u15c3\u15c4\u0005"+ + "\u01bd\u0000\u0000\u15c4\u15c8\u0003\u0296\u014b\u0000\u15c5\u15c8\u0005"+ + "j\u0000\u0000\u15c6\u15c8\u0003\u0290\u0148\u0000\u15c7\u15bf\u0001\u0000"+ + "\u0000\u0000\u15c7\u15c1\u0001\u0000\u0000\u0000\u15c7\u15c3\u0001\u0000"+ + "\u0000\u0000\u15c7\u15c5\u0001\u0000\u0000\u0000\u15c7\u15c6\u0001\u0000"+ + "\u0000\u0000\u15c8\u0293\u0001\u0000\u0000\u0000\u15c9\u15cf\u0003\u054e"+ + "\u02a7\u0000\u15ca\u15cb\u0003\u054e\u02a7\u0000\u15cb\u15cc\u0005\u0007"+ + "\u0000\u0000\u15cc\u15cd\u0003\u054e\u02a7\u0000\u15cd\u15cf\u0001\u0000"+ + "\u0000\u0000\u15ce\u15c9\u0001\u0000\u0000\u0000\u15ce\u15ca\u0001\u0000"+ + "\u0000\u0000\u15cf\u0295\u0001\u0000\u0000\u0000\u15d0\u15d1\u0005@\u0000"+ + "\u0000\u15d1\u15d2\u0005\u0163\u0000\u0000\u15d2\u15d9\u0003\u0460\u0230"+ + "\u0000\u15d3\u15d4\u0005\u0007\u0000\u0000\u15d4\u15d5\u0005@\u0000\u0000"+ + "\u15d5\u15d6\u0005\u0163\u0000\u0000\u15d6\u15d8\u0003\u0460\u0230\u0000"+ + "\u15d7\u15d3\u0001\u0000\u0000\u0000\u15d8\u15db\u0001\u0000\u0000\u0000"+ + "\u15d9\u15d7\u0001\u0000\u0000\u0000\u15d9\u15da\u0001\u0000\u0000\u0000"+ + "\u15da\u0297\u0001\u0000\u0000\u0000\u15db\u15d9\u0001\u0000\u0000\u0000"+ + "\u15dc\u15dd\u0005k\u0000\u0000\u15dd\u15e0\u0003\u01cc\u00e6\u0000\u15de"+ + "\u15e0\u0001\u0000\u0000\u0000\u15df\u15dc\u0001\u0000\u0000\u0000\u15df"+ + "\u15de\u0001\u0000\u0000\u0000\u15e0\u0299\u0001\u0000\u0000\u0000\u15e1"+ + "\u15e2\u0003\u027c\u013e\u0000\u15e2\u15e3\u0003\u0280\u0140\u0000\u15e3"+ + "\u029b\u0001\u0000\u0000\u0000\u15e4\u15e9\u0003\u029a\u014d\u0000\u15e5"+ + "\u15e6\u0005\u0007\u0000\u0000\u15e6\u15e8\u0003\u029a\u014d\u0000\u15e7"+ + "\u15e5\u0001\u0000\u0000\u0000\u15e8\u15eb\u0001\u0000\u0000\u0000\u15e9"+ + "\u15e7\u0001\u0000\u0000\u0000\u15e9\u15ea\u0001\u0000\u0000\u0000\u15ea"+ + "\u029d\u0001\u0000\u0000\u0000\u15eb\u15e9\u0001\u0000\u0000\u0000\u15ec"+ + "\u15ed\u0005\u008c\u0000\u0000\u15ed\u15ee\u0007\u001b\u0000\u0000\u15ee"+ + "\u15ef\u0003\u0272\u0139\u0000\u15ef\u15f0\u0003\u02a0\u0150\u0000\u15f0"+ + "\u15f1\u0003\u02a2\u0151\u0000\u15f1\u029f\u0001\u0000\u0000\u0000\u15f2"+ + "\u15f4\u0003\u0290\u0148\u0000\u15f3\u15f2\u0001\u0000\u0000\u0000\u15f4"+ + "\u15f5\u0001\u0000\u0000\u0000\u15f5\u15f3\u0001\u0000\u0000\u0000\u15f5"+ + "\u15f6\u0001\u0000\u0000\u0000\u15f6\u02a1\u0001\u0000\u0000\u0000\u15f7"+ + "\u15fa\u0005\u0136\u0000\u0000\u15f8\u15fa\u0001\u0000\u0000\u0000\u15f9"+ + "\u15f7\u0001\u0000\u0000\u0000\u15f9\u15f8\u0001\u0000\u0000\u0000\u15fa"+ + "\u02a3\u0001\u0000\u0000\u0000\u15fb\u15fc\u0005\u00c1\u0000\u0000\u15fc"+ + "\u15fd\u0005\u00d5\u0000\u0000\u15fd\u15fe\u0003\u0270\u0138\u0000\u15fe"+ + "\u15ff\u0003l6\u0000\u15ff\u1620\u0001\u0000\u0000\u0000\u1600\u1601\u0005"+ + "\u00c1\u0000\u0000\u1601\u1602\u0005\u00d5\u0000\u0000\u1602\u1603\u0005"+ + "\u00de\u0000\u0000\u1603\u1604\u0005\u0187\u0000\u0000\u1604\u1605\u0003"+ + "\u0270\u0138\u0000\u1605\u1606\u0003l6\u0000\u1606\u1620\u0001\u0000\u0000"+ + "\u0000\u1607\u1608\u0005\u00c1\u0000\u0000\u1608\u1609\u0005\u0123\u0000"+ + "\u0000\u1609\u160a\u0003\u0270\u0138\u0000\u160a\u160b\u0003l6\u0000\u160b"+ + "\u1620\u0001\u0000\u0000\u0000\u160c\u160d\u0005\u00c1\u0000\u0000\u160d"+ + "\u160e\u0005\u0123\u0000\u0000\u160e\u160f\u0005\u00de\u0000\u0000\u160f"+ + "\u1610\u0005\u0187\u0000\u0000\u1610\u1611\u0003\u0270\u0138\u0000\u1611"+ + "\u1612\u0003l6\u0000\u1612\u1620\u0001\u0000\u0000\u0000\u1613\u1614\u0005"+ + "\u00c1\u0000\u0000\u1614\u1615\u0005\u01bc\u0000\u0000\u1615\u1616\u0003"+ + "\u0270\u0138\u0000\u1616\u1617\u0003l6\u0000\u1617\u1620\u0001\u0000\u0000"+ + "\u0000\u1618\u1619\u0005\u00c1\u0000\u0000\u1619\u161a\u0005\u01bc\u0000"+ + "\u0000\u161a\u161b\u0005\u00de\u0000\u0000\u161b\u161c\u0005\u0187\u0000"+ + "\u0000\u161c\u161d\u0003\u0270\u0138\u0000\u161d\u161e\u0003l6\u0000\u161e"+ + "\u1620\u0001\u0000\u0000\u0000\u161f\u15fb\u0001\u0000\u0000\u0000\u161f"+ + "\u1600\u0001\u0000\u0000\u0000\u161f\u1607\u0001\u0000\u0000\u0000\u161f"+ + "\u160c\u0001\u0000\u0000\u0000\u161f\u1613\u0001\u0000\u0000\u0000\u161f"+ + "\u1618\u0001\u0000\u0000\u0000\u1620\u02a5\u0001\u0000\u0000\u0000\u1621"+ + "\u1622\u0005\u00c1\u0000\u0000\u1622\u1623\u0005\u008a\u0000\u0000\u1623"+ + "\u1624\u0003\u028c\u0146\u0000\u1624\u1625\u0003l6\u0000\u1625\u162e\u0001"+ + "\u0000\u0000\u0000\u1626\u1627\u0005\u00c1\u0000\u0000\u1627\u1628\u0005"+ + "\u008a\u0000\u0000\u1628\u1629\u0005\u00de\u0000\u0000\u1629\u162a\u0005"+ + "\u0187\u0000\u0000\u162a\u162b\u0003\u028c\u0146\u0000\u162b\u162c\u0003"+ + "l6\u0000\u162c\u162e\u0001\u0000\u0000\u0000\u162d\u1621\u0001\u0000\u0000"+ + "\u0000\u162d\u1626\u0001\u0000\u0000\u0000\u162e\u02a7\u0001\u0000\u0000"+ + "\u0000\u162f\u1630\u0005\u00c1\u0000\u0000\u1630\u1631\u0005\u0111\u0000"+ + "\u0000\u1631\u1632\u0003\u02ae\u0157\u0000\u1632\u1633\u0003l6\u0000\u1633"+ + "\u163c\u0001\u0000\u0000\u0000\u1634\u1635\u0005\u00c1\u0000\u0000\u1635"+ + "\u1636\u0005\u0111\u0000\u0000\u1636\u1637\u0005\u00de\u0000\u0000\u1637"+ + "\u1638\u0005\u0187\u0000\u0000\u1638\u1639\u0003\u02ae\u0157\u0000\u1639"+ + "\u163a\u0003l6\u0000\u163a\u163c\u0001\u0000\u0000\u0000\u163b\u162f\u0001"+ + "\u0000\u0000\u0000\u163b\u1634\u0001\u0000\u0000\u0000\u163c\u02a9\u0001"+ + "\u0000\u0000\u0000\u163d\u163e\u0005\u0003\u0000\u0000\u163e\u163f\u0003"+ + "\u0460\u0230\u0000\u163f\u1640\u0005\u0004\u0000\u0000\u1640\u1654\u0001"+ + "\u0000\u0000\u0000\u1641\u1642\u0005\u0003\u0000\u0000\u1642\u1643\u0003"+ + "\u0460\u0230\u0000\u1643\u1644\u0005\u0007\u0000\u0000\u1644\u1645\u0003"+ + "\u0460\u0230\u0000\u1645\u1646\u0005\u0004\u0000\u0000\u1646\u1654\u0001"+ + "\u0000\u0000\u0000\u1647\u1648\u0005\u0003\u0000\u0000\u1648\u1649\u0005"+ + "\u0192\u0000\u0000\u1649\u164a\u0005\u0007\u0000\u0000\u164a\u164b\u0003"+ + "\u0460\u0230\u0000\u164b\u164c\u0005\u0004\u0000\u0000\u164c\u1654\u0001"+ + "\u0000\u0000\u0000\u164d\u164e\u0005\u0003\u0000\u0000\u164e\u164f\u0003"+ + "\u0460\u0230\u0000\u164f\u1650\u0005\u0007\u0000\u0000\u1650\u1651\u0005"+ + "\u0192\u0000\u0000\u1651\u1652\u0005\u0004\u0000\u0000\u1652\u1654\u0001"+ + "\u0000\u0000\u0000\u1653\u163d\u0001\u0000\u0000\u0000\u1653\u1641\u0001"+ + "\u0000\u0000\u0000\u1653\u1647\u0001\u0000\u0000\u0000\u1653\u164d\u0001"+ + "\u0000\u0000\u0000\u1654\u02ab\u0001\u0000\u0000\u0000\u1655\u1656\u0003"+ + "\u055c\u02ae\u0000\u1656\u1657\u0005\r\u0000\u0000\u1657\u1659\u0001\u0000"+ + "\u0000\u0000\u1658\u1655\u0001\u0000\u0000\u0000\u1659\u165c\u0001\u0000"+ + "\u0000\u0000\u165a\u1658\u0001\u0000\u0000\u0000\u165a\u165b\u0001\u0000"+ + "\u0000\u0000\u165b\u165d\u0001\u0000\u0000\u0000\u165c\u165a\u0001\u0000"+ + "\u0000\u0000\u165d\u165e\u0003\u04f6\u027b\u0000\u165e\u02ad\u0001\u0000"+ + "\u0000\u0000\u165f\u1664\u0003\u02b0\u0158\u0000\u1660\u1661\u0005\u0007"+ + "\u0000\u0000\u1661\u1663\u0003\u02b0\u0158\u0000\u1662\u1660\u0001\u0000"+ + "\u0000\u0000\u1663\u1666\u0001\u0000\u0000\u0000\u1664\u1662\u0001\u0000"+ + "\u0000\u0000\u1664\u1665\u0001\u0000\u0000\u0000\u1665\u02af\u0001\u0000"+ + "\u0000\u0000\u1666\u1664\u0001\u0000\u0000\u0000\u1667\u1668\u0003\u02ac"+ + "\u0156\u0000\u1668\u1669\u0003\u02aa\u0155\u0000\u1669\u02b1\u0001\u0000"+ + "\u0000\u0000\u166a\u166b\u0005;\u0000\u0000\u166b\u166c\u0003\u02b4\u015a"+ + "\u0000\u166c\u02b3\u0001\u0000\u0000\u0000\u166d\u166f\u0003\u02b6\u015b"+ + "\u0000\u166e\u166d\u0001\u0000\u0000\u0000\u166f\u1670\u0001\u0000\u0000"+ + "\u0000\u1670\u166e\u0001\u0000\u0000\u0000\u1670\u1671\u0001\u0000\u0000"+ + "\u0000\u1671\u02b5\u0001\u0000\u0000\u0000\u1672\u1676\u0003\u054e\u02a7"+ + "\u0000\u1673\u1674\u0005\u00f0\u0000\u0000\u1674\u1676\u0003H$\u0000\u1675"+ + "\u1672\u0001\u0000\u0000\u0000\u1675\u1673\u0001\u0000\u0000\u0000\u1676"+ + "\u02b7\u0001\u0000\u0000\u0000\u1677\u1678\u00050\u0000\u0000\u1678\u1679"+ + "\u0005+\u0000\u0000\u1679\u167a\u0005\u0003\u0000\u0000\u167a\u167b\u0003"+ + "\u0460\u0230\u0000\u167b\u167c\u0005&\u0000\u0000\u167c\u167d\u0003\u0460"+ + "\u0230\u0000\u167d\u167e\u0005\u0004\u0000\u0000\u167e\u167f\u0005k\u0000"+ + "\u0000\u167f\u1680\u0005\u00d5\u0000\u0000\u1680\u1681\u0003\u0272\u0139"+ + "\u0000\u1681\u1682\u0003\u02ba\u015d\u0000\u1682\u169a\u0001\u0000\u0000"+ + "\u0000\u1683\u1684\u00050\u0000\u0000\u1684\u1685\u0005+\u0000\u0000\u1685"+ + "\u1686\u0005\u0003\u0000\u0000\u1686\u1687\u0003\u0460\u0230\u0000\u1687"+ + "\u1688\u0005&\u0000\u0000\u1688\u1689\u0003\u0460\u0230\u0000\u1689\u168a"+ + "\u0005\u0004\u0000\u0000\u168a\u168b\u0005\u0176\u0000\u0000\u168b\u168c"+ + "\u0005\u00d5\u0000\u0000\u168c\u168d\u0003\u02ba\u015d\u0000\u168d\u169a"+ + "\u0001\u0000\u0000\u0000\u168e\u168f\u00050\u0000\u0000\u168f\u1690\u0005"+ + "+\u0000\u0000\u1690\u1691\u0005\u0003\u0000\u0000\u1691\u1692\u0003\u0460"+ + "\u0230\u0000\u1692\u1693\u0005&\u0000\u0000\u1693\u1694\u0003\u0460\u0230"+ + "\u0000\u1694\u1695\u0005\u0004\u0000\u0000\u1695\u1696\u0005k\u0000\u0000"+ + "\u1696\u1697\u0005\u018b\u0000\u0000\u1697\u1698\u0003\u02ba\u015d\u0000"+ + "\u1698\u169a\u0001\u0000\u0000\u0000\u1699\u1677\u0001\u0000\u0000\u0000"+ + "\u1699\u1683\u0001\u0000\u0000\u0000\u1699\u168e\u0001\u0000\u0000\u0000"+ + "\u169a\u02b9\u0001\u0000\u0000\u0000\u169b\u169c\u0005&\u0000\u0000\u169c"+ + "\u16a1\u0005\u00e1\u0000\u0000\u169d\u169e\u0005&\u0000\u0000\u169e\u16a1"+ + "\u0005\u008f\u0000\u0000\u169f\u16a1\u0001\u0000\u0000\u0000\u16a0\u169b"+ + "\u0001\u0000\u0000\u0000\u16a0\u169d\u0001\u0000\u0000\u0000\u16a0\u169f"+ + "\u0001\u0000\u0000\u0000\u16a1\u02bb\u0001\u0000\u0000\u0000\u16a2\u16a3"+ + "\u0005\u00c1\u0000\u0000\u16a3\u16a4\u0005+\u0000\u0000\u16a4\u16a5\u0003"+ + "\u02be\u015f\u0000\u16a5\u16a6\u0005\u0003\u0000\u0000\u16a6\u16a7\u0003"+ + "\u0460\u0230\u0000\u16a7\u16a8\u0005&\u0000\u0000\u16a8\u16a9\u0003\u0460"+ + "\u0230\u0000\u16a9\u16aa\u0005\u0004\u0000\u0000\u16aa\u16ab\u0003l6\u0000"+ + "\u16ab\u02bd\u0001\u0000\u0000\u0000\u16ac\u16ad\u0005\u00de\u0000\u0000"+ + "\u16ad\u16b0\u0005\u0187\u0000\u0000\u16ae\u16b0\u0001\u0000\u0000\u0000"+ + "\u16af\u16ac\u0001\u0000\u0000\u0000\u16af\u16ae\u0001\u0000\u0000\u0000"+ + "\u16b0\u02bf\u0001\u0000\u0000\u0000\u16b1\u16b2\u00050\u0000\u0000\u16b2"+ + "\u16b3\u0003\u026a\u0135\u0000\u16b3\u16b4\u0005\u01bd\u0000\u0000\u16b4"+ + "\u16b5\u0005@\u0000\u0000\u16b5\u16b6\u0003\u0460\u0230\u0000\u16b6\u16b7"+ + "\u0005\u00f0\u0000\u0000\u16b7\u16b8\u0003\u053c\u029e\u0000\u16b8\u16b9"+ + "\u0005\u0003\u0000\u0000\u16b9\u16ba\u0003\u02c2\u0161\u0000\u16ba\u16bb"+ + "\u0005\u0004\u0000\u0000\u16bb\u02c1\u0001\u0000\u0000\u0000\u16bc\u16bd"+ + "\u0005B\u0000\u0000\u16bd\u16be\u0005\u01cf\u0000\u0000\u16be\u16bf\u0005"+ + "k\u0000\u0000\u16bf\u16c0\u0005\u00d5\u0000\u0000\u16c0\u16c1\u0003\u0272"+ + "\u0139\u0000\u16c1\u16c2\u0005\u0007\u0000\u0000\u16c2\u16c3\u0005`\u0000"+ + "\u0000\u16c3\u16c4\u0005\u01cf\u0000\u0000\u16c4\u16c5\u0005k\u0000\u0000"+ + "\u16c5\u16c6\u0005\u00d5\u0000\u0000\u16c6\u16c7\u0003\u0272\u0139\u0000"+ + "\u16c7\u16df\u0001\u0000\u0000\u0000\u16c8\u16c9\u0005`\u0000\u0000\u16c9"+ + "\u16ca\u0005\u01cf\u0000\u0000\u16ca\u16cb\u0005k\u0000\u0000\u16cb\u16cc"+ + "\u0005\u00d5\u0000\u0000\u16cc\u16cd\u0003\u0272\u0139\u0000\u16cd\u16ce"+ + "\u0005\u0007\u0000\u0000\u16ce\u16cf\u0005B\u0000\u0000\u16cf\u16d0\u0005"+ + "\u01cf\u0000\u0000\u16d0\u16d1\u0005k\u0000\u0000\u16d1\u16d2\u0005\u00d5"+ + "\u0000\u0000\u16d2\u16d3\u0003\u0272\u0139\u0000\u16d3\u16df\u0001\u0000"+ + "\u0000\u0000\u16d4\u16d5\u0005B\u0000\u0000\u16d5\u16d6\u0005\u01cf\u0000"+ + "\u0000\u16d6\u16d7\u0005k\u0000\u0000\u16d7\u16d8\u0005\u00d5\u0000\u0000"+ + "\u16d8\u16df\u0003\u0272\u0139\u0000\u16d9\u16da\u0005`\u0000\u0000\u16da"+ + "\u16db\u0005\u01cf\u0000\u0000\u16db\u16dc\u0005k\u0000\u0000\u16dc\u16dd"+ + "\u0005\u00d5\u0000\u0000\u16dd\u16df\u0003\u0272\u0139\u0000\u16de\u16bc"+ + "\u0001\u0000\u0000\u0000\u16de\u16c8\u0001\u0000\u0000\u0000\u16de\u16d4"+ + "\u0001\u0000\u0000\u0000\u16de\u16d9\u0001\u0000\u0000\u0000\u16df\u02c3"+ + "\u0001\u0000\u0000\u0000\u16e0\u16e1\u0005\u00c1\u0000\u0000\u16e1\u16e2"+ + "\u0005\u01bd\u0000\u0000\u16e2\u16e3\u0003\u02be\u015f\u0000\u16e3\u16e4"+ + "\u0005@\u0000\u0000\u16e4\u16e5\u0003\u0460\u0230\u0000\u16e5\u16e6\u0005"+ + "\u00f0\u0000\u0000\u16e6\u16e7\u0003\u053c\u029e\u0000\u16e7\u16e8\u0003"+ + "l6\u0000\u16e8\u02c5\u0001\u0000\u0000\u0000\u16e9\u16ea\u0005\u012d\u0000"+ + "\u0000\u16ea\u16eb\u0003\u02c8\u0164\u0000\u16eb\u16ec\u0003\u0250\u0128"+ + "\u0000\u16ec\u16ed\u0003\u0538\u029c\u0000\u16ed\u1704\u0001\u0000\u0000"+ + "\u0000\u16ee\u16ef\u0005\u012d\u0000\u0000\u16ef\u16f0\u0003\u02ca\u0165"+ + "\u0000\u16f0\u16f1\u0003\u0250\u0128\u0000\u16f1\u16f2\u0003\u053c\u029e"+ + "\u0000\u16f2\u1704\u0001\u0000\u0000\u0000\u16f3\u16f4\u0005\u012d\u0000"+ + "\u0000\u16f4\u16f5\u0005\u0003\u0000\u0000\u16f5\u16f6\u0003\u02cc\u0166"+ + "\u0000\u16f6\u16f7\u0005\u0004\u0000\u0000\u16f7\u16f8\u0003\u02c8\u0164"+ + "\u0000\u16f8\u16f9\u0003\u0250\u0128\u0000\u16f9\u16fa\u0003\u0538\u029c"+ + "\u0000\u16fa\u1704\u0001\u0000\u0000\u0000\u16fb\u16fc\u0005\u012d\u0000"+ + "\u0000\u16fc\u16fd\u0005\u0003\u0000\u0000\u16fd\u16fe\u0003\u02cc\u0166"+ + "\u0000\u16fe\u16ff\u0005\u0004\u0000\u0000\u16ff\u1700\u0003\u02ca\u0165"+ + "\u0000\u1700\u1701\u0003\u0250\u0128\u0000\u1701\u1702\u0003\u053c\u029e"+ + "\u0000\u1702\u1704\u0001\u0000\u0000\u0000\u1703\u16e9\u0001\u0000\u0000"+ + "\u0000\u1703\u16ee\u0001\u0000\u0000\u0000\u1703\u16f3\u0001\u0000\u0000"+ + "\u0000\u1703\u16fb\u0001\u0000\u0000\u0000\u1704\u02c7\u0001\u0000\u0000"+ + "\u0000\u1705\u1706\u0007\u001c\u0000\u0000\u1706\u02c9\u0001\u0000\u0000"+ + "\u0000\u1707\u1708\u0007\u001d\u0000\u0000\u1708\u02cb\u0001\u0000\u0000"+ + "\u0000\u1709\u170e\u0003\u02ce\u0167\u0000\u170a\u170b\u0005\u0007\u0000"+ + "\u0000\u170b\u170d\u0003\u02ce\u0167\u0000\u170c\u170a\u0001\u0000\u0000"+ + "\u0000\u170d\u1710\u0001\u0000\u0000\u0000\u170e\u170c\u0001\u0000\u0000"+ + "\u0000\u170e\u170f\u0001\u0000\u0000\u0000\u170f\u02cd\u0001\u0000\u0000"+ + "\u0000\u1710\u170e\u0001\u0000\u0000\u0000\u1711\u1712\u0007\u001e\u0000"+ + "\u0000\u1712\u02cf\u0001\u0000\u0000\u0000\u1713\u1714\u0005\u008c\u0000"+ + "\u0000\u1714\u1715\u0005\u015a\u0000\u0000\u1715\u1716\u0003\u053c\u029e"+ + "\u0000\u1716\u1717\u0005\u0148\u0000\u0000\u1717\u1718\u0003t:\u0000\u1718"+ + "\u1720\u0001\u0000\u0000\u0000\u1719\u171a\u0005\u008c\u0000\u0000\u171a"+ + "\u171b\u0005\u015a\u0000\u0000\u171b\u171c\u0003\u053c\u029e\u0000\u171c"+ + "\u171d\u0005\u0134\u0000\u0000\u171d\u171e\u0003t:\u0000\u171e\u1720\u0001"+ + "\u0000\u0000\u0000\u171f\u1713\u0001\u0000\u0000\u0000\u171f\u1719\u0001"+ + "\u0000\u0000\u0000\u1720\u02d1\u0001\u0000\u0000\u0000\u1721\u1722\u0005"+ + "\u008c\u0000\u0000\u1722\u1723\u0005\u008a\u0000\u0000\u1723\u1724\u0003"+ + "\u028a\u0145\u0000\u1724\u1725\u0005\u0130\u0000\u0000\u1725\u1726\u0005"+ + "`\u0000\u0000\u1726\u1727\u0003\u053c\u029e\u0000\u1727\u18f6\u0001\u0000"+ + "\u0000\u0000\u1728\u1729\u0005\u008c\u0000\u0000\u1729\u172a\u0005n\u0000"+ + "\u0000\u172a\u172b\u0003\u020c\u0106\u0000\u172b\u172c\u0005\u0130\u0000"+ + "\u0000\u172c\u172d\u0005`\u0000\u0000\u172d\u172e\u0003\u053c\u029e\u0000"+ + "\u172e\u18f6\u0001\u0000\u0000\u0000\u172f\u1730\u0005\u008c\u0000\u0000"+ + "\u1730\u1731\u0005\u00aa\u0000\u0000\u1731\u1732\u0003\u020c\u0106\u0000"+ + "\u1732\u1733\u0005\u0130\u0000\u0000\u1733\u1734\u0005`\u0000\u0000\u1734"+ + "\u1735\u0003\u053c\u029e\u0000\u1735\u18f6\u0001\u0000\u0000\u0000\u1736"+ + "\u1737\u0005\u008c\u0000\u0000\u1737\u1738\u0005\u00b1\u0000\u0000\u1738"+ + "\u1739\u0003\u053c\u029e\u0000\u1739\u173a\u0005\u0130\u0000\u0000\u173a"+ + "\u173b\u0005`\u0000\u0000\u173b\u173c\u0003\u053c\u029e\u0000\u173c\u18f6"+ + "\u0001\u0000\u0000\u0000\u173d\u173e\u0005\u008c\u0000\u0000\u173e\u173f"+ + "\u0005\u00bf\u0000\u0000\u173f\u1740\u0003\u020c\u0106\u0000\u1740\u1741"+ + "\u0005\u0130\u0000\u0000\u1741\u1742\u0005`\u0000\u0000\u1742\u1743\u0003"+ + "\u053c\u029e\u0000\u1743\u18f6\u0001\u0000\u0000\u0000\u1744\u1745\u0005"+ + "\u008c\u0000\u0000\u1745\u1746\u0005\u00bf\u0000\u0000\u1746\u1747\u0003"+ + "\u020c\u0106\u0000\u1747\u1748\u0005\u0130\u0000\u0000\u1748\u1749\u0005"+ + "/\u0000\u0000\u1749\u174a\u0003\u053c\u029e\u0000\u174a\u174b\u0005`\u0000"+ + "\u0000\u174b\u174c\u0003\u053c\u029e\u0000\u174c\u18f6\u0001\u0000\u0000"+ + "\u0000\u174d\u174e\u0005\u008c\u0000\u0000\u174e\u174f\u0005A\u0000\u0000"+ + "\u174f\u1750\u0005\u00b0\u0000\u0000\u1750\u1751\u0005\u0178\u0000\u0000"+ + "\u1751\u1752\u0003\u053c\u029e\u0000\u1752\u1753\u0005\u0130\u0000\u0000"+ + "\u1753\u1754\u0005`\u0000\u0000\u1754\u1755\u0003\u053c\u029e\u0000\u1755"+ + "\u18f6\u0001\u0000\u0000\u0000\u1756\u1757\u0005\u008c\u0000\u0000\u1757"+ + "\u1758\u0005\u00d5\u0000\u0000\u1758\u1759\u0003\u0272\u0139\u0000\u1759"+ + "\u175a\u0005\u0130\u0000\u0000\u175a\u175b\u0005`\u0000\u0000\u175b\u175c"+ + "\u0003\u053c\u029e\u0000\u175c\u18f6\u0001\u0000\u0000\u0000\u175d\u175e"+ + "\u0005\u008c\u0000\u0000\u175e\u175f\u0005D\u0000\u0000\u175f\u1760\u0003"+ + "\u0556\u02ab\u0000\u1760\u1761\u0005\u0130\u0000\u0000\u1761\u1762\u0005"+ + "`\u0000\u0000\u1762\u1763\u0003\u0556\u02ab\u0000\u1763\u18f6\u0001\u0000"+ + "\u0000\u0000\u1764\u1765\u0005\u008c\u0000\u0000\u1765\u1766\u0003\u0134"+ + "\u009a\u0000\u1766\u1767\u0005\u00f0\u0000\u0000\u1767\u1768\u0003\u053c"+ + "\u029e\u0000\u1768\u1769\u0005\u0130\u0000\u0000\u1769\u176a\u0005`\u0000"+ + "\u0000\u176a\u176b\u0003\u053c\u029e\u0000\u176b\u18f6\u0001\u0000\u0000"+ + "\u0000\u176c\u176d\u0005\u008c\u0000\u0000\u176d\u176e\u0005\u0111\u0000"+ + "\u0000\u176e\u176f\u0005\u009e\u0000\u0000\u176f\u1770\u0003\u020c\u0106"+ + "\u0000\u1770\u1771\u0005f\u0000\u0000\u1771\u1772\u0003\u053c\u029e\u0000"+ + "\u1772\u1773\u0005\u0130\u0000\u0000\u1773\u1774\u0005`\u0000\u0000\u1774"+ + "\u1775\u0003\u053c\u029e\u0000\u1775\u18f6\u0001\u0000\u0000\u0000\u1776"+ + "\u1777\u0005\u008c\u0000\u0000\u1777\u1778\u0005\u0111\u0000\u0000\u1778"+ + "\u1779\u0005\u00d0\u0000\u0000\u1779\u177a\u0003\u020c\u0106\u0000\u177a"+ + "\u177b\u0005f\u0000\u0000\u177b\u177c\u0003\u053c\u029e\u0000\u177c\u177d"+ + "\u0005\u0130\u0000\u0000\u177d\u177e\u0005`\u0000\u0000\u177e\u177f\u0003"+ + "\u053c\u029e\u0000\u177f\u18f6\u0001\u0000\u0000\u0000\u1780\u1781\u0005"+ + "\u008c\u0000\u0000\u1781\u1782\u0005\u01bf\u0000\u0000\u1782\u1783\u0003"+ + "\u053c\u029e\u0000\u1783\u1784\u0005R\u0000\u0000\u1784\u1785\u0003\u0538"+ + "\u029c\u0000\u1785\u1786\u0005\u0130\u0000\u0000\u1786\u1787\u0005`\u0000"+ + "\u0000\u1787\u1788\u0003\u053c\u029e\u0000\u1788\u18f6\u0001\u0000\u0000"+ + "\u0000\u1789\u178a\u0005\u008c\u0000\u0000\u178a\u178b\u0005\u01bf\u0000"+ + "\u0000\u178b\u178c\u0005\u00de\u0000\u0000\u178c\u178d\u0005\u0187\u0000"+ + "\u0000\u178d\u178e\u0003\u053c\u029e\u0000\u178e\u178f\u0005R\u0000\u0000"+ + "\u178f\u1790\u0003\u0538\u029c\u0000\u1790\u1791\u0005\u0130\u0000\u0000"+ + "\u1791\u1792\u0005`\u0000\u0000\u1792\u1793\u0003\u053c\u029e\u0000\u1793"+ + "\u18f6\u0001\u0000\u0000\u0000\u1794\u1795\u0005\u008c\u0000\u0000\u1795"+ + "\u1796\u0005\u0123\u0000\u0000\u1796\u1797\u0003\u0272\u0139\u0000\u1797"+ + "\u1798\u0005\u0130\u0000\u0000\u1798\u1799\u0005`\u0000\u0000\u1799\u179a"+ + "\u0003\u053c\u029e\u0000\u179a\u18f6\u0001\u0000\u0000\u0000\u179b\u179c"+ + "\u0005\u008c\u0000\u0000\u179c\u179d\u0005\u01c6\u0000\u0000\u179d\u179e"+ + "\u0003\u053c\u029e\u0000\u179e\u179f\u0005\u0130\u0000\u0000\u179f\u17a0"+ + "\u0005`\u0000\u0000\u17a0\u17a1\u0003\u053c\u029e\u0000\u17a1\u18f6\u0001"+ + "\u0000\u0000\u0000\u17a2\u17a3\u0005\u008c\u0000\u0000\u17a3\u17a4\u0005"+ + "\u01bc\u0000\u0000\u17a4\u17a5\u0003\u0272\u0139\u0000\u17a5\u17a6\u0005"+ + "\u0130\u0000\u0000\u17a6\u17a7\u0005`\u0000\u0000\u17a7\u17a8\u0003\u053c"+ + "\u029e\u0000\u17a8\u18f6\u0001\u0000\u0000\u0000\u17a9\u17aa\u0005\u008c"+ + "\u0000\u0000\u17aa\u17ab\u0005\u013e\u0000\u0000\u17ab\u17ac\u0003\u053c"+ + "\u029e\u0000\u17ac\u17ad\u0005\u0130\u0000\u0000\u17ad\u17ae\u0005`\u0000"+ + "\u0000\u17ae\u17af\u0003\u053c\u029e\u0000\u17af\u18f6\u0001\u0000\u0000"+ + "\u0000\u17b0\u17b1\u0005\u008c\u0000\u0000\u17b1\u17b2\u0005\u0146\u0000"+ + "\u0000\u17b2\u17b3\u0003\u053c\u029e\u0000\u17b3\u17b4\u0005\u0130\u0000"+ + "\u0000\u17b4\u17b5\u0005`\u0000\u0000\u17b5\u17b6\u0003\u053c\u029e\u0000"+ + "\u17b6\u18f6\u0001\u0000\u0000\u0000\u17b7\u17b8\u0005\u008c\u0000\u0000"+ + "\u17b8\u17b9\u0005\u01c5\u0000\u0000\u17b9\u17ba\u0003\u053c\u029e\u0000"+ + "\u17ba\u17bb\u0005\u0130\u0000\u0000\u17bb\u17bc\u0005`\u0000\u0000\u17bc"+ + "\u17bd\u0003\u053c\u029e\u0000\u17bd\u18f6\u0001\u0000\u0000\u0000\u17be"+ + "\u17bf\u0005\u008c\u0000\u0000\u17bf\u17c0\u0005^\u0000\u0000\u17c0\u17c1"+ + "\u0003\u0434\u021a\u0000\u17c1\u17c2\u0005\u0130\u0000\u0000\u17c2\u17c3"+ + "\u0005`\u0000\u0000\u17c3\u17c4\u0003\u053c\u029e\u0000\u17c4\u18f6\u0001"+ + "\u0000\u0000\u0000\u17c5\u17c6\u0005\u008c\u0000\u0000\u17c6\u17c7\u0005"+ + "^\u0000\u0000\u17c7\u17c8\u0005\u00de\u0000\u0000\u17c8\u17c9\u0005\u0187"+ + "\u0000\u0000\u17c9\u17ca\u0003\u0434\u021a\u0000\u17ca\u17cb\u0005\u0130"+ + "\u0000\u0000\u17cb\u17cc\u0005`\u0000\u0000\u17cc\u17cd\u0003\u053c\u029e"+ + "\u0000\u17cd\u18f6\u0001\u0000\u0000\u0000\u17ce\u17cf\u0005\u008c\u0000"+ + "\u0000\u17cf\u17d0\u0005\u0143\u0000\u0000\u17d0\u17d1\u0003\u0538\u029c"+ + "\u0000\u17d1\u17d2\u0005\u0130\u0000\u0000\u17d2\u17d3\u0005`\u0000\u0000"+ + "\u17d3\u17d4\u0003\u053c\u029e\u0000\u17d4\u18f6\u0001\u0000\u0000\u0000"+ + "\u17d5\u17d6\u0005\u008c\u0000\u0000\u17d6\u17d7\u0005\u0143\u0000\u0000"+ + "\u17d7\u17d8\u0005\u00de\u0000\u0000\u17d8\u17d9\u0005\u0187\u0000\u0000"+ + "\u17d9\u17da\u0003\u0538\u029c\u0000\u17da\u17db\u0005\u0130\u0000\u0000"+ + "\u17db\u17dc\u0005`\u0000\u0000\u17dc\u17dd\u0003\u053c\u029e\u0000\u17dd"+ + "\u18f6\u0001\u0000\u0000\u0000\u17de\u17df\u0005\u008c\u0000\u0000\u17df"+ + "\u17e0\u0005\u0173\u0000\u0000\u17e0\u17e1\u0003\u0538\u029c\u0000\u17e1"+ + "\u17e2\u0005\u0130\u0000\u0000\u17e2\u17e3\u0005`\u0000\u0000\u17e3\u17e4"+ + "\u0003\u053c\u029e\u0000\u17e4\u18f6\u0001\u0000\u0000\u0000\u17e5\u17e6"+ + "\u0005\u008c\u0000\u0000\u17e6\u17e7\u0005\u0173\u0000\u0000\u17e7\u17e8"+ + "\u0005\u00de\u0000\u0000\u17e8\u17e9\u0005\u0187\u0000\u0000\u17e9\u17ea"+ + "\u0003\u0538\u029c\u0000\u17ea\u17eb\u0005\u0130\u0000\u0000\u17eb\u17ec"+ + "\u0005`\u0000\u0000\u17ec\u17ed\u0003\u053c\u029e\u0000\u17ed\u18f6\u0001"+ + "\u0000\u0000\u0000\u17ee\u17ef\u0005\u008c\u0000\u0000\u17ef\u17f0\u0005"+ + "\u00fd\u0000\u0000\u17f0\u17f1\u0005\u0173\u0000\u0000\u17f1\u17f2\u0003"+ + "\u0538\u029c\u0000\u17f2\u17f3\u0005\u0130\u0000\u0000\u17f3\u17f4\u0005"+ + "`\u0000\u0000\u17f4\u17f5\u0003\u053c\u029e\u0000\u17f5\u18f6\u0001\u0000"+ + "\u0000\u0000\u17f6\u17f7\u0005\u008c\u0000\u0000\u17f7\u17f8\u0005\u00fd"+ + "\u0000\u0000\u17f8\u17f9\u0005\u0173\u0000\u0000\u17f9\u17fa\u0005\u00de"+ + "\u0000\u0000\u17fa\u17fb\u0005\u0187\u0000\u0000\u17fb\u17fc\u0003\u0538"+ + "\u029c\u0000\u17fc\u17fd\u0005\u0130\u0000\u0000\u17fd\u17fe\u0005`\u0000"+ + "\u0000\u17fe\u17ff\u0003\u053c\u029e\u0000\u17ff\u18f6\u0001\u0000\u0000"+ + "\u0000\u1800\u1801\u0005\u008c\u0000\u0000\u1801\u1802\u0005\u00e4\u0000"+ + "\u0000\u1802\u1803\u0003\u0538\u029c\u0000\u1803\u1804\u0005\u0130\u0000"+ + "\u0000\u1804\u1805\u0005`\u0000\u0000\u1805\u1806\u0003\u053c\u029e\u0000"+ + "\u1806\u18f6\u0001\u0000\u0000\u0000\u1807\u1808\u0005\u008c\u0000\u0000"+ + "\u1808\u1809\u0005\u00e4\u0000\u0000\u1809\u180a\u0005\u00de\u0000\u0000"+ + "\u180a\u180b\u0005\u0187\u0000\u0000\u180b\u180c\u0003\u0538\u029c\u0000"+ + "\u180c\u180d\u0005\u0130\u0000\u0000\u180d\u180e\u0005`\u0000\u0000\u180e"+ + "\u180f\u0003\u053c\u029e\u0000\u180f\u18f6\u0001\u0000\u0000\u0000\u1810"+ + "\u1811\u0005\u008c\u0000\u0000\u1811\u1812\u0005A\u0000\u0000\u1812\u1813"+ + "\u0005^\u0000\u0000\u1813\u1814\u0003\u0434\u021a\u0000\u1814\u1815\u0005"+ + "\u0130\u0000\u0000\u1815\u1816\u0005`\u0000\u0000\u1816\u1817\u0003\u053c"+ + "\u029e\u0000\u1817\u18f6\u0001\u0000\u0000\u0000\u1818\u1819\u0005\u008c"+ + "\u0000\u0000\u1819\u181a\u0005A\u0000\u0000\u181a\u181b\u0005^\u0000\u0000"+ + "\u181b\u181c\u0005\u00de\u0000\u0000\u181c\u181d\u0005\u0187\u0000\u0000"+ + "\u181d\u181e\u0003\u0434\u021a\u0000\u181e\u181f\u0005\u0130\u0000\u0000"+ + "\u181f\u1820\u0005`\u0000\u0000\u1820\u1821\u0003\u053c\u029e\u0000\u1821"+ + "\u18f6\u0001\u0000\u0000\u0000\u1822\u1823\u0005\u008c\u0000\u0000\u1823"+ + "\u1824\u0005^\u0000\u0000\u1824\u1825\u0003\u0434\u021a\u0000\u1825\u1826"+ + "\u0005\u0130\u0000\u0000\u1826\u1827\u0003\u02d4\u016a\u0000\u1827\u1828"+ + "\u0003\u053c\u029e\u0000\u1828\u1829\u0005`\u0000\u0000\u1829\u182a\u0003"+ + "\u053c\u029e\u0000\u182a\u18f6\u0001\u0000\u0000\u0000\u182b\u182c\u0005"+ + "\u008c\u0000\u0000\u182c\u182d\u0005^\u0000\u0000\u182d\u182e\u0005\u00de"+ + "\u0000\u0000\u182e\u182f\u0005\u0187\u0000\u0000\u182f\u1830\u0003\u0434"+ + "\u021a\u0000\u1830\u1831\u0005\u0130\u0000\u0000\u1831\u1832\u0003\u02d4"+ + "\u016a\u0000\u1832\u1833\u0003\u053c\u029e\u0000\u1833\u1834\u0005`\u0000"+ + "\u0000\u1834\u1835\u0003\u053c\u029e\u0000\u1835\u18f6\u0001\u0000\u0000"+ + "\u0000\u1836\u1837\u0005\u008c\u0000\u0000\u1837\u1838\u0005\u0173\u0000"+ + "\u0000\u1838\u1839\u0003\u0538\u029c\u0000\u1839\u183a\u0005\u0130\u0000"+ + "\u0000\u183a\u183b\u0003\u02d4\u016a\u0000\u183b\u183c\u0003\u053c\u029e"+ + "\u0000\u183c\u183d\u0005`\u0000\u0000\u183d\u183e\u0003\u053c\u029e\u0000"+ + "\u183e\u18f6\u0001\u0000\u0000\u0000\u183f\u1840\u0005\u008c\u0000\u0000"+ + "\u1840\u1841\u0005\u0173\u0000\u0000\u1841\u1842\u0005\u00de\u0000\u0000"+ + "\u1842\u1843\u0005\u0187\u0000\u0000\u1843\u1844\u0003\u0538\u029c\u0000"+ + "\u1844\u1845\u0005\u0130\u0000\u0000\u1845\u1846\u0003\u02d4\u016a\u0000"+ + "\u1846\u1847\u0003\u053c\u029e\u0000\u1847\u1848\u0005`\u0000\u0000\u1848"+ + "\u1849\u0003\u053c\u029e\u0000\u1849\u18f6\u0001\u0000\u0000\u0000\u184a"+ + "\u184b\u0005\u008c\u0000\u0000\u184b\u184c\u0005\u00fd\u0000\u0000\u184c"+ + "\u184d\u0005\u0173\u0000\u0000\u184d\u184e\u0003\u0538\u029c\u0000\u184e"+ + "\u184f\u0005\u0130\u0000\u0000\u184f\u1850\u0003\u02d4\u016a\u0000\u1850"+ + "\u1851\u0003\u053c\u029e\u0000\u1851\u1852\u0005`\u0000\u0000\u1852\u1853"+ + "\u0003\u053c\u029e\u0000\u1853\u18f6\u0001\u0000\u0000\u0000\u1854\u1855"+ + "\u0005\u008c\u0000\u0000\u1855\u1856\u0005\u00fd\u0000\u0000\u1856\u1857"+ + "\u0005\u0173\u0000\u0000\u1857\u1858\u0005\u00de\u0000\u0000\u1858\u1859"+ + "\u0005\u0187\u0000\u0000\u1859\u185a\u0003\u0538\u029c\u0000\u185a\u185b"+ + "\u0005\u0130\u0000\u0000\u185b\u185c\u0003\u02d4\u016a\u0000\u185c\u185d"+ + "\u0003\u053c\u029e\u0000\u185d\u185e\u0005`\u0000\u0000\u185e\u185f\u0003"+ + "\u053c\u029e\u0000\u185f\u18f6\u0001\u0000\u0000\u0000\u1860\u1861\u0005"+ + "\u008c\u0000\u0000\u1861\u1862\u0005^\u0000\u0000\u1862\u1863\u0003\u0434"+ + "\u021a\u0000\u1863\u1864\u0005\u0130\u0000\u0000\u1864\u1865\u0005/\u0000"+ + "\u0000\u1865\u1866\u0003\u053c\u029e\u0000\u1866\u1867\u0005`\u0000\u0000"+ + "\u1867\u1868\u0003\u053c\u029e\u0000\u1868\u18f6\u0001\u0000\u0000\u0000"+ + "\u1869\u186a\u0005\u008c\u0000\u0000\u186a\u186b\u0005^\u0000\u0000\u186b"+ + "\u186c\u0005\u00de\u0000\u0000\u186c\u186d\u0005\u0187\u0000\u0000\u186d"+ + "\u186e\u0003\u0434\u021a\u0000\u186e\u186f\u0005\u0130\u0000\u0000\u186f"+ + "\u1870\u0005/\u0000\u0000\u1870\u1871\u0003\u053c\u029e\u0000\u1871\u1872"+ + "\u0005`\u0000\u0000\u1872\u1873\u0003\u053c\u029e\u0000\u1873\u18f6\u0001"+ + "\u0000\u0000\u0000\u1874\u1875\u0005\u008c\u0000\u0000\u1875\u1876\u0005"+ + "A\u0000\u0000\u1876\u1877\u0005^\u0000\u0000\u1877\u1878\u0003\u0434\u021a"+ + "\u0000\u1878\u1879\u0005\u0130\u0000\u0000\u1879\u187a\u0003\u02d4\u016a"+ + "\u0000\u187a\u187b\u0003\u053c\u029e\u0000\u187b\u187c\u0005`\u0000\u0000"+ + "\u187c\u187d\u0003\u053c\u029e\u0000\u187d\u18f6\u0001\u0000\u0000\u0000"+ + "\u187e\u187f\u0005\u008c\u0000\u0000\u187f\u1880\u0005A\u0000\u0000\u1880"+ + "\u1881\u0005^\u0000\u0000\u1881\u1882\u0005\u00de\u0000\u0000\u1882\u1883"+ + "\u0005\u0187\u0000\u0000\u1883\u1884\u0003\u0434\u021a\u0000\u1884\u1885"+ + "\u0005\u0130\u0000\u0000\u1885\u1886\u0003\u02d4\u016a\u0000\u1886\u1887"+ + "\u0003\u053c\u029e\u0000\u1887\u1888\u0005`\u0000\u0000\u1888\u1889\u0003"+ + "\u053c\u029e\u0000\u1889\u18f6\u0001\u0000\u0000\u0000\u188a\u188b\u0005"+ + "\u008c\u0000\u0000\u188b\u188c\u0005\u013c\u0000\u0000\u188c\u188d\u0003"+ + "\u053c\u029e\u0000\u188d\u188e\u0005R\u0000\u0000\u188e\u188f\u0003\u0538"+ + "\u029c\u0000\u188f\u1890\u0005\u0130\u0000\u0000\u1890\u1891\u0005`\u0000"+ + "\u0000\u1891\u1892\u0003\u053c\u029e\u0000\u1892\u18f6\u0001\u0000\u0000"+ + "\u0000\u1893\u1894\u0005\u008c\u0000\u0000\u1894\u1895\u0005\u0160\u0000"+ + "\u0000\u1895\u1896\u0003\u053c\u029e\u0000\u1896\u1897\u0005R\u0000\u0000"+ + "\u1897\u1898\u0003\u0538\u029c\u0000\u1898\u1899\u0005\u0130\u0000\u0000"+ + "\u1899\u189a\u0005`\u0000\u0000\u189a\u189b\u0003\u053c\u029e\u0000\u189b"+ + "\u18f6\u0001\u0000\u0000\u0000\u189c\u189d\u0005\u008c\u0000\u0000\u189d"+ + "\u189e\u0005\u00c8\u0000\u0000\u189e\u189f\u0005\u0160\u0000\u0000\u189f"+ + "\u18a0\u0003\u053c\u029e\u0000\u18a0\u18a1\u0005\u0130\u0000\u0000\u18a1"+ + "\u18a2\u0005`\u0000\u0000\u18a2\u18a3\u0003\u053c\u029e\u0000\u18a3\u18f6"+ + "\u0001\u0000\u0000\u0000\u18a4\u18a5\u0005\u008c\u0000\u0000\u18a5\u18a6"+ + "\u0005\u0139\u0000\u0000\u18a6\u18a7\u0003\u0556\u02ab\u0000\u18a7\u18a8"+ + "\u0005\u0130\u0000\u0000\u18a8\u18a9\u0005`\u0000\u0000\u18a9\u18aa\u0003"+ + "\u0556\u02ab\u0000\u18aa\u18f6\u0001\u0000\u0000\u0000\u18ab\u18ac\u0005"+ + "\u008c\u0000\u0000\u18ac\u18ad\u0005e\u0000\u0000\u18ad\u18ae\u0003\u0556"+ + "\u02ab\u0000\u18ae\u18af\u0005\u0130\u0000\u0000\u18af\u18b0\u0005`\u0000"+ + "\u0000\u18b0\u18b1\u0003\u0556\u02ab\u0000\u18b1\u18f6\u0001\u0000\u0000"+ + "\u0000\u18b2\u18b3\u0005\u008c\u0000\u0000\u18b3\u18b4\u0005\u015a\u0000"+ + "\u0000\u18b4\u18b5\u0003\u053c\u029e\u0000\u18b5\u18b6\u0005\u0130\u0000"+ + "\u0000\u18b6\u18b7\u0005`\u0000\u0000\u18b7\u18b8\u0003\u053c\u029e\u0000"+ + "\u18b8\u18f6\u0001\u0000\u0000\u0000\u18b9\u18ba\u0005\u008c\u0000\u0000"+ + "\u18ba\u18bb\u0005\u0151\u0000\u0000\u18bb\u18bc\u0003\u020c\u0106\u0000"+ + "\u18bc\u18bd\u0005\u0130\u0000\u0000\u18bd\u18be\u0005`\u0000\u0000\u18be"+ + "\u18bf\u0003\u053c\u029e\u0000\u18bf\u18f6\u0001\u0000\u0000\u0000\u18c0"+ + "\u18c1\u0005\u008c\u0000\u0000\u18c1\u18c2\u0005\u015e\u0000\u0000\u18c2"+ + "\u18c3\u0005\u0140\u0000\u0000\u18c3\u18c4\u0005\u0116\u0000\u0000\u18c4"+ + "\u18c5\u0003\u020c\u0106\u0000\u18c5\u18c6\u0005\u0130\u0000\u0000\u18c6"+ + "\u18c7\u0005`\u0000\u0000\u18c7\u18c8\u0003\u053c\u029e\u0000\u18c8\u18f6"+ + "\u0001\u0000\u0000\u0000\u18c9\u18ca\u0005\u008c\u0000\u0000\u18ca\u18cb"+ + "\u0005\u015e\u0000\u0000\u18cb\u18cc\u0005\u0140\u0000\u0000\u18cc\u18cd"+ + "\u0005\u00bb\u0000\u0000\u18cd\u18ce\u0003\u020c\u0106\u0000\u18ce\u18cf"+ + "\u0005\u0130\u0000\u0000\u18cf\u18d0\u0005`\u0000\u0000\u18d0\u18d1\u0003"+ + "\u053c\u029e\u0000\u18d1\u18f6\u0001\u0000\u0000\u0000\u18d2\u18d3\u0005"+ + "\u008c\u0000\u0000\u18d3\u18d4\u0005\u015e\u0000\u0000\u18d4\u18d5\u0005"+ + "\u0140\u0000\u0000\u18d5\u18d6\u0005\u015c\u0000\u0000\u18d6\u18d7\u0003"+ + "\u020c\u0106\u0000\u18d7\u18d8\u0005\u0130\u0000\u0000\u18d8\u18d9\u0005"+ + "`\u0000\u0000\u18d9\u18da\u0003\u053c\u029e\u0000\u18da\u18f6\u0001\u0000"+ + "\u0000\u0000\u18db\u18dc\u0005\u008c\u0000\u0000\u18dc\u18dd\u0005\u015e"+ + "\u0000\u0000\u18dd\u18de\u0005\u0140\u0000\u0000\u18de\u18df\u0005\u00a5"+ + "\u0000\u0000\u18df\u18e0\u0003\u020c\u0106\u0000\u18e0\u18e1\u0005\u0130"+ + "\u0000\u0000\u18e1\u18e2\u0005`\u0000\u0000\u18e2\u18e3\u0003\u053c\u029e"+ + "\u0000\u18e3\u18f6\u0001\u0000\u0000\u0000\u18e4\u18e5\u0005\u008c\u0000"+ + "\u0000\u18e5\u18e6\u0005\u0163\u0000\u0000\u18e6\u18e7\u0003\u020c\u0106"+ + "\u0000\u18e7\u18e8\u0005\u0130\u0000\u0000\u18e8\u18e9\u0005`\u0000\u0000"+ + "\u18e9\u18ea\u0003\u053c\u029e\u0000\u18ea\u18f6\u0001\u0000\u0000\u0000"+ + "\u18eb\u18ec\u0005\u008c\u0000\u0000\u18ec\u18ed\u0005\u0163\u0000\u0000"+ + "\u18ed\u18ee\u0003\u020c\u0106\u0000\u18ee\u18ef\u0005\u0130\u0000\u0000"+ + "\u18ef\u18f0\u0005\u0091\u0000\u0000\u18f0\u18f1\u0003\u053c\u029e\u0000"+ + "\u18f1\u18f2\u0005`\u0000\u0000\u18f2\u18f3\u0003\u053c\u029e\u0000\u18f3"+ + "\u18f4\u0003l6\u0000\u18f4\u18f6\u0001\u0000\u0000\u0000\u18f5\u1721\u0001"+ + "\u0000\u0000\u0000\u18f5\u1728\u0001\u0000\u0000\u0000\u18f5\u172f\u0001"+ + "\u0000\u0000\u0000\u18f5\u1736\u0001\u0000\u0000\u0000\u18f5\u173d\u0001"+ + "\u0000\u0000\u0000\u18f5\u1744\u0001\u0000\u0000\u0000\u18f5\u174d\u0001"+ + "\u0000\u0000\u0000\u18f5\u1756\u0001\u0000\u0000\u0000\u18f5\u175d\u0001"+ + "\u0000\u0000\u0000\u18f5\u1764\u0001\u0000\u0000\u0000\u18f5\u176c\u0001"+ + "\u0000\u0000\u0000\u18f5\u1776\u0001\u0000\u0000\u0000\u18f5\u1780\u0001"+ + "\u0000\u0000\u0000\u18f5\u1789\u0001\u0000\u0000\u0000\u18f5\u1794\u0001"+ + "\u0000\u0000\u0000\u18f5\u179b\u0001\u0000\u0000\u0000\u18f5\u17a2\u0001"+ + "\u0000\u0000\u0000\u18f5\u17a9\u0001\u0000\u0000\u0000\u18f5\u17b0\u0001"+ + "\u0000\u0000\u0000\u18f5\u17b7\u0001\u0000\u0000\u0000\u18f5\u17be\u0001"+ + "\u0000\u0000\u0000\u18f5\u17c5\u0001\u0000\u0000\u0000\u18f5\u17ce\u0001"+ + "\u0000\u0000\u0000\u18f5\u17d5\u0001\u0000\u0000\u0000\u18f5\u17de\u0001"+ + "\u0000\u0000\u0000\u18f5\u17e5\u0001\u0000\u0000\u0000\u18f5\u17ee\u0001"+ + "\u0000\u0000\u0000\u18f5\u17f6\u0001\u0000\u0000\u0000\u18f5\u1800\u0001"+ + "\u0000\u0000\u0000\u18f5\u1807\u0001\u0000\u0000\u0000\u18f5\u1810\u0001"+ + "\u0000\u0000\u0000\u18f5\u1818\u0001\u0000\u0000\u0000\u18f5\u1822\u0001"+ + "\u0000\u0000\u0000\u18f5\u182b\u0001\u0000\u0000\u0000\u18f5\u1836\u0001"+ + "\u0000\u0000\u0000\u18f5\u183f\u0001\u0000\u0000\u0000\u18f5\u184a\u0001"+ + "\u0000\u0000\u0000\u18f5\u1854\u0001\u0000\u0000\u0000\u18f5\u1860\u0001"+ + "\u0000\u0000\u0000\u18f5\u1869\u0001\u0000\u0000\u0000\u18f5\u1874\u0001"+ + "\u0000\u0000\u0000\u18f5\u187e\u0001\u0000\u0000\u0000\u18f5\u188a\u0001"+ + "\u0000\u0000\u0000\u18f5\u1893\u0001\u0000\u0000\u0000\u18f5\u189c\u0001"+ + "\u0000\u0000\u0000\u18f5\u18a4\u0001\u0000\u0000\u0000\u18f5\u18ab\u0001"+ + "\u0000\u0000\u0000\u18f5\u18b2\u0001\u0000\u0000\u0000\u18f5\u18b9\u0001"+ + "\u0000\u0000\u0000\u18f5\u18c0\u0001\u0000\u0000\u0000\u18f5\u18c9\u0001"+ + "\u0000\u0000\u0000\u18f5\u18d2\u0001\u0000\u0000\u0000\u18f5\u18db\u0001"+ + "\u0000\u0000\u0000\u18f5\u18e4\u0001\u0000\u0000\u0000\u18f5\u18eb\u0001"+ + "\u0000\u0000\u0000\u18f6\u02d3\u0001\u0000\u0000\u0000\u18f7\u18fa\u0005"+ + ".\u0000\u0000\u18f8\u18fa\u0001\u0000\u0000\u0000\u18f9\u18f7\u0001\u0000"+ + "\u0000\u0000\u18f9\u18f8\u0001\u0000\u0000\u0000\u18fa\u02d5\u0001\u0000"+ + "\u0000\u0000\u18fb\u18fc\u0005\u0148\u0000\u0000\u18fc\u18ff\u0005\u00b0"+ + "\u0000\u0000\u18fd\u18ff\u0001\u0000\u0000\u0000\u18fe\u18fb\u0001\u0000"+ + "\u0000\u0000\u18fe\u18fd\u0001\u0000\u0000\u0000\u18ff\u02d7\u0001\u0000"+ + "\u0000\u0000\u1900\u1901\u0005\u008c\u0000\u0000\u1901\u1902\u0005\u00d5"+ + "\u0000\u0000\u1902\u1903\u0003\u0272\u0139\u0000\u1903\u1904\u0003\u02da"+ + "\u016d\u0000\u1904\u1905\u0005\u01d0\u0000\u0000\u1905\u1906\u0005R\u0000"+ + "\u0000\u1906\u1907\u0005\u00ce\u0000\u0000\u1907\u1908\u0003\u053c\u029e"+ + "\u0000\u1908\u193a\u0001\u0000\u0000\u0000\u1909\u190a\u0005\u008c\u0000"+ + "\u0000\u190a\u190b\u0005\u0123\u0000\u0000\u190b\u190c\u0003\u0272\u0139"+ + "\u0000\u190c\u190d\u0003\u02da\u016d\u0000\u190d\u190e\u0005\u01d0\u0000"+ + "\u0000\u190e\u190f\u0005R\u0000\u0000\u190f\u1910\u0005\u00ce\u0000\u0000"+ + "\u1910\u1911\u0003\u053c\u029e\u0000\u1911\u193a\u0001\u0000\u0000\u0000"+ + "\u1912\u1913\u0005\u008c\u0000\u0000\u1913\u1914\u0005\u01bc\u0000\u0000"+ + "\u1914\u1915\u0003\u0272\u0139\u0000\u1915\u1916\u0003\u02da\u016d\u0000"+ + "\u1916\u1917\u0005\u01d0\u0000\u0000\u1917\u1918\u0005R\u0000\u0000\u1918"+ + "\u1919\u0005\u00ce\u0000\u0000\u1919\u191a\u0003\u053c\u029e\u0000\u191a"+ + "\u193a\u0001\u0000\u0000\u0000\u191b\u191c\u0005\u008c\u0000\u0000\u191c"+ + "\u191d\u0005\u0160\u0000\u0000\u191d\u191e\u0003\u053c\u029e\u0000\u191e"+ + "\u191f\u0005R\u0000\u0000\u191f\u1920\u0003\u0538\u029c\u0000\u1920\u1921"+ + "\u0003\u02da\u016d\u0000\u1921\u1922\u0005\u01d0\u0000\u0000\u1922\u1923"+ + "\u0005R\u0000\u0000\u1923\u1924\u0005\u00ce\u0000\u0000\u1924\u1925\u0003"+ + "\u053c\u029e\u0000\u1925\u193a\u0001\u0000\u0000\u0000\u1926\u1927\u0005"+ + "\u008c\u0000\u0000\u1927\u1928\u0005\u00fd\u0000\u0000\u1928\u1929\u0005"+ + "\u0173\u0000\u0000\u1929\u192a\u0003\u0538\u029c\u0000\u192a\u192b\u0003"+ + "\u02da\u016d\u0000\u192b\u192c\u0005\u01d0\u0000\u0000\u192c\u192d\u0005"+ + "R\u0000\u0000\u192d\u192e\u0005\u00ce\u0000\u0000\u192e\u192f\u0003\u053c"+ + "\u029e\u0000\u192f\u193a\u0001\u0000\u0000\u0000\u1930\u1931\u0005\u008c"+ + "\u0000\u0000\u1931\u1932\u0005\u00e4\u0000\u0000\u1932\u1933\u0003\u0538"+ + "\u029c\u0000\u1933\u1934\u0003\u02da\u016d\u0000\u1934\u1935\u0005\u01d0"+ + "\u0000\u0000\u1935\u1936\u0005R\u0000\u0000\u1936\u1937\u0005\u00ce\u0000"+ + "\u0000\u1937\u1938\u0003\u053c\u029e\u0000\u1938\u193a\u0001\u0000\u0000"+ + "\u0000\u1939\u1900\u0001\u0000\u0000\u0000\u1939\u1909\u0001\u0000\u0000"+ + "\u0000\u1939\u1912\u0001\u0000\u0000\u0000\u1939\u191b\u0001\u0000\u0000"+ + "\u0000\u1939\u1926\u0001\u0000\u0000\u0000\u1939\u1930\u0001\u0000\u0000"+ + "\u0000\u193a\u02d9\u0001\u0000\u0000\u0000\u193b\u193e\u0005\u0108\u0000"+ + "\u0000\u193c\u193e\u0001\u0000\u0000\u0000\u193d\u193b\u0001\u0000\u0000"+ + "\u0000\u193d\u193c\u0001\u0000\u0000\u0000\u193e\u02db\u0001\u0000\u0000"+ + "\u0000\u193f\u1940\u0005\u008c\u0000\u0000\u1940\u1941\u0005\u008a\u0000"+ + "\u0000\u1941\u1942\u0003\u028a\u0145\u0000\u1942\u1943\u0005\u0148\u0000"+ + "\u0000\u1943\u1944\u0005\u013e\u0000\u0000\u1944\u1945\u0003\u053c\u029e"+ + "\u0000\u1945\u1a19\u0001\u0000\u0000\u0000\u1946\u1947\u0005\u008c\u0000"+ + "\u0000\u1947\u1948\u0005n\u0000\u0000\u1948\u1949\u0003\u020c\u0106\u0000"+ + "\u1949\u194a\u0005\u0148\u0000\u0000\u194a\u194b\u0005\u013e\u0000\u0000"+ + "\u194b\u194c\u0003\u053c\u029e\u0000\u194c\u1a19\u0001\u0000\u0000\u0000"+ + "\u194d\u194e\u0005\u008c\u0000\u0000\u194e\u194f\u0005\u00aa\u0000\u0000"+ + "\u194f\u1950\u0003\u020c\u0106\u0000\u1950\u1951\u0005\u0148\u0000\u0000"+ + "\u1951\u1952\u0005\u013e\u0000\u0000\u1952\u1953\u0003\u053c\u029e\u0000"+ + "\u1953\u1a19\u0001\u0000\u0000\u0000\u1954\u1955\u0005\u008c\u0000\u0000"+ + "\u1955\u1956\u0005\u00bf\u0000\u0000\u1956\u1957\u0003\u020c\u0106\u0000"+ + "\u1957\u1958\u0005\u0148\u0000\u0000\u1958\u1959\u0005\u013e\u0000\u0000"+ + "\u1959\u195a\u0003\u053c\u029e\u0000\u195a\u1a19\u0001\u0000\u0000\u0000"+ + "\u195b\u195c\u0005\u008c\u0000\u0000\u195c\u195d\u0005\u00ce\u0000\u0000"+ + "\u195d\u195e\u0003\u053c\u029e\u0000\u195e\u195f\u0005\u0148\u0000\u0000"+ + "\u195f\u1960\u0005\u013e\u0000\u0000\u1960\u1961\u0003\u053c\u029e\u0000"+ + "\u1961\u1a19\u0001\u0000\u0000\u0000\u1962\u1963\u0005\u008c\u0000\u0000"+ + "\u1963\u1964\u0005\u00d5\u0000\u0000\u1964\u1965\u0003\u0272\u0139\u0000"+ + "\u1965\u1966\u0005\u0148\u0000\u0000\u1966\u1967\u0005\u013e\u0000\u0000"+ + "\u1967\u1968\u0003\u053c\u029e\u0000\u1968\u1a19\u0001\u0000\u0000\u0000"+ + "\u1969\u196a\u0005\u008c\u0000\u0000\u196a\u196b\u0005\u0111\u0000\u0000"+ + "\u196b\u196c\u0003\u02b0\u0158\u0000\u196c\u196d\u0005\u0148\u0000\u0000"+ + "\u196d\u196e\u0005\u013e\u0000\u0000\u196e\u196f\u0003\u053c\u029e\u0000"+ + "\u196f\u1a19\u0001\u0000\u0000\u0000\u1970\u1971\u0005\u008c\u0000\u0000"+ + "\u1971\u1972\u0005\u0111\u0000\u0000\u1972\u1973\u0005\u009e\u0000\u0000"+ + "\u1973\u1974\u0003\u020c\u0106\u0000\u1974\u1975\u0005f\u0000\u0000\u1975"+ + "\u1976\u0003\u053c\u029e\u0000\u1976\u1977\u0005\u0148\u0000\u0000\u1977"+ + "\u1978\u0005\u013e\u0000\u0000\u1978\u1979\u0003\u053c\u029e\u0000\u1979"+ + "\u1a19\u0001\u0000\u0000\u0000\u197a\u197b\u0005\u008c\u0000\u0000\u197b"+ + "\u197c\u0005\u0111\u0000\u0000\u197c\u197d\u0005\u00d0\u0000\u0000\u197d"+ + "\u197e\u0003\u020c\u0106\u0000\u197e\u197f\u0005f\u0000\u0000\u197f\u1980"+ + "\u0003\u053c\u029e\u0000\u1980\u1981\u0005\u0148\u0000\u0000\u1981\u1982"+ + "\u0005\u013e\u0000\u0000\u1982\u1983\u0003\u053c\u029e\u0000\u1983\u1a19"+ + "\u0001\u0000\u0000\u0000\u1984\u1985\u0005\u008c\u0000\u0000\u1985\u1986"+ + "\u0005\u0123\u0000\u0000\u1986\u1987\u0003\u0272\u0139\u0000\u1987\u1988"+ + "\u0005\u0148\u0000\u0000\u1988\u1989\u0005\u013e\u0000\u0000\u1989\u198a"+ + "\u0003\u053c\u029e\u0000\u198a\u1a19\u0001\u0000\u0000\u0000\u198b\u198c"+ + "\u0005\u008c\u0000\u0000\u198c\u198d\u0005\u01bc\u0000\u0000\u198d\u198e"+ + "\u0003\u0272\u0139\u0000\u198e\u198f\u0005\u0148\u0000\u0000\u198f\u1990"+ + "\u0005\u013e\u0000\u0000\u1990\u1991\u0003\u053c\u029e\u0000\u1991\u1a19"+ + "\u0001\u0000\u0000\u0000\u1992\u1993\u0005\u008c\u0000\u0000\u1993\u1994"+ + "\u0005^\u0000\u0000\u1994\u1995\u0003\u0434\u021a\u0000\u1995\u1996\u0005"+ + "\u0148\u0000\u0000\u1996\u1997\u0005\u013e\u0000\u0000\u1997\u1998\u0003"+ + "\u053c\u029e\u0000\u1998\u1a19\u0001\u0000\u0000\u0000\u1999\u199a\u0005"+ + "\u008c\u0000\u0000\u199a\u199b\u0005^\u0000\u0000\u199b\u199c\u0005\u00de"+ + "\u0000\u0000\u199c\u199d\u0005\u0187\u0000\u0000\u199d\u199e\u0003\u0434"+ + "\u021a\u0000\u199e\u199f\u0005\u0148\u0000\u0000\u199f\u19a0\u0005\u013e"+ + "\u0000\u0000\u19a0\u19a1\u0003\u053c\u029e\u0000\u19a1\u1a19\u0001\u0000"+ + "\u0000\u0000\u19a2\u19a3\u0005\u008c\u0000\u0000\u19a3\u19a4\u0005\u0151"+ + "\u0000\u0000\u19a4\u19a5\u0003\u020c\u0106\u0000\u19a5\u19a6\u0005\u0148"+ + "\u0000\u0000\u19a6\u19a7\u0005\u013e\u0000\u0000\u19a7\u19a8\u0003\u053c"+ + "\u029e\u0000\u19a8\u1a19\u0001\u0000\u0000\u0000\u19a9\u19aa\u0005\u008c"+ + "\u0000\u0000\u19aa\u19ab\u0005\u015e\u0000\u0000\u19ab\u19ac\u0005\u0140"+ + "\u0000\u0000\u19ac\u19ad\u0005\u0116\u0000\u0000\u19ad\u19ae\u0003\u020c"+ + "\u0106\u0000\u19ae\u19af\u0005\u0148\u0000\u0000\u19af\u19b0\u0005\u013e"+ + "\u0000\u0000\u19b0\u19b1\u0003\u053c\u029e\u0000\u19b1\u1a19\u0001\u0000"+ + "\u0000\u0000\u19b2\u19b3\u0005\u008c\u0000\u0000\u19b3\u19b4\u0005\u015e"+ + "\u0000\u0000\u19b4\u19b5\u0005\u0140\u0000\u0000\u19b5\u19b6\u0005\u00bb"+ + "\u0000\u0000\u19b6\u19b7\u0003\u020c\u0106\u0000\u19b7\u19b8\u0005\u0148"+ + "\u0000\u0000\u19b8\u19b9\u0005\u013e\u0000\u0000\u19b9\u19ba\u0003\u053c"+ + "\u029e\u0000\u19ba\u1a19\u0001\u0000\u0000\u0000\u19bb\u19bc\u0005\u008c"+ + "\u0000\u0000\u19bc\u19bd\u0005\u015e\u0000\u0000\u19bd\u19be\u0005\u0140"+ + "\u0000\u0000\u19be\u19bf\u0005\u015c\u0000\u0000\u19bf\u19c0\u0003\u020c"+ + "\u0106\u0000\u19c0\u19c1\u0005\u0148\u0000\u0000\u19c1\u19c2\u0005\u013e"+ + "\u0000\u0000\u19c2\u19c3\u0003\u053c\u029e\u0000\u19c3\u1a19\u0001\u0000"+ + "\u0000\u0000\u19c4\u19c5\u0005\u008c\u0000\u0000\u19c5\u19c6\u0005\u015e"+ + "\u0000\u0000\u19c6\u19c7\u0005\u0140\u0000\u0000\u19c7\u19c8\u0005\u00a5"+ + "\u0000\u0000\u19c8\u19c9\u0003\u020c\u0106\u0000\u19c9\u19ca\u0005\u0148"+ + "\u0000\u0000\u19ca\u19cb\u0005\u013e\u0000\u0000\u19cb\u19cc\u0003\u053c"+ + "\u029e\u0000\u19cc\u1a19\u0001\u0000\u0000\u0000\u19cd\u19ce\u0005\u008c"+ + "\u0000\u0000\u19ce\u19cf\u0005\u0143\u0000\u0000\u19cf\u19d0\u0003\u0538"+ + "\u029c\u0000\u19d0\u19d1\u0005\u0148\u0000\u0000\u19d1\u19d2\u0005\u013e"+ + "\u0000\u0000\u19d2\u19d3\u0003\u053c\u029e\u0000\u19d3\u1a19\u0001\u0000"+ + "\u0000\u0000\u19d4\u19d5\u0005\u008c\u0000\u0000\u19d5\u19d6\u0005\u0143"+ + "\u0000\u0000\u19d6\u19d7\u0005\u00de\u0000\u0000\u19d7\u19d8\u0005\u0187"+ + "\u0000\u0000\u19d8\u19d9\u0003\u0538\u029c\u0000\u19d9\u19da\u0005\u0148"+ + "\u0000\u0000\u19da\u19db\u0005\u013e\u0000\u0000\u19db\u19dc\u0003\u053c"+ + "\u029e\u0000\u19dc\u1a19\u0001\u0000\u0000\u0000\u19dd\u19de\u0005\u008c"+ + "\u0000\u0000\u19de\u19df\u0005\u0173\u0000\u0000\u19df\u19e0\u0003\u0538"+ + "\u029c\u0000\u19e0\u19e1\u0005\u0148\u0000\u0000\u19e1\u19e2\u0005\u013e"+ + "\u0000\u0000\u19e2\u19e3\u0003\u053c\u029e\u0000\u19e3\u1a19\u0001\u0000"+ + "\u0000\u0000\u19e4\u19e5\u0005\u008c\u0000\u0000\u19e5\u19e6\u0005\u0173"+ + "\u0000\u0000\u19e6\u19e7\u0005\u00de\u0000\u0000\u19e7\u19e8\u0005\u0187"+ + "\u0000\u0000\u19e8\u19e9\u0003\u0538\u029c\u0000\u19e9\u19ea\u0005\u0148"+ + "\u0000\u0000\u19ea\u19eb\u0005\u013e\u0000\u0000\u19eb\u19ec\u0003\u053c"+ + "\u029e\u0000\u19ec\u1a19\u0001\u0000\u0000\u0000\u19ed\u19ee\u0005\u008c"+ + "\u0000\u0000\u19ee\u19ef\u0005\u00fd\u0000\u0000\u19ef\u19f0\u0005\u0173"+ + "\u0000\u0000\u19f0\u19f1\u0003\u0538\u029c\u0000\u19f1\u19f2\u0005\u0148"+ + "\u0000\u0000\u19f2\u19f3\u0005\u013e\u0000\u0000\u19f3\u19f4\u0003\u053c"+ + "\u029e\u0000\u19f4\u1a19\u0001\u0000\u0000\u0000\u19f5\u19f6\u0005\u008c"+ + "\u0000\u0000\u19f6\u19f7\u0005\u00fd\u0000\u0000\u19f7\u19f8\u0005\u0173"+ + "\u0000\u0000\u19f8\u19f9\u0005\u00de\u0000\u0000\u19f9\u19fa\u0005\u0187"+ + "\u0000\u0000\u19fa\u19fb\u0003\u0538\u029c\u0000\u19fb\u19fc\u0005\u0148"+ + "\u0000\u0000\u19fc\u19fd\u0005\u013e\u0000\u0000\u19fd\u19fe\u0003\u053c"+ + "\u029e\u0000\u19fe\u1a19\u0001\u0000\u0000\u0000\u19ff\u1a00\u0005\u008c"+ + "\u0000\u0000\u1a00\u1a01\u0005A\u0000\u0000\u1a01\u1a02\u0005^\u0000\u0000"+ + "\u1a02\u1a03\u0003\u0434\u021a\u0000\u1a03\u1a04\u0005\u0148\u0000\u0000"+ + "\u1a04\u1a05\u0005\u013e\u0000\u0000\u1a05\u1a06\u0003\u053c\u029e\u0000"+ + "\u1a06\u1a19\u0001\u0000\u0000\u0000\u1a07\u1a08\u0005\u008c\u0000\u0000"+ + "\u1a08\u1a09\u0005A\u0000\u0000\u1a09\u1a0a\u0005^\u0000\u0000\u1a0a\u1a0b"+ + "\u0005\u00de\u0000\u0000\u1a0b\u1a0c\u0005\u0187\u0000\u0000\u1a0c\u1a0d"+ + "\u0003\u0434\u021a\u0000\u1a0d\u1a0e\u0005\u0148\u0000\u0000\u1a0e\u1a0f"+ + "\u0005\u013e\u0000\u0000\u1a0f\u1a10\u0003\u053c\u029e\u0000\u1a10\u1a19"+ + "\u0001\u0000\u0000\u0000\u1a11\u1a12\u0005\u008c\u0000\u0000\u1a12\u1a13"+ + "\u0005\u0163\u0000\u0000\u1a13\u1a14\u0003\u020c\u0106\u0000\u1a14\u1a15"+ + "\u0005\u0148\u0000\u0000\u1a15\u1a16\u0005\u013e\u0000\u0000\u1a16\u1a17"+ + "\u0003\u053c\u029e\u0000\u1a17\u1a19\u0001\u0000\u0000\u0000\u1a18\u193f"+ + "\u0001\u0000\u0000\u0000\u1a18\u1946\u0001\u0000\u0000\u0000\u1a18\u194d"+ + "\u0001\u0000\u0000\u0000\u1a18\u1954\u0001\u0000\u0000\u0000\u1a18\u195b"+ + "\u0001\u0000\u0000\u0000\u1a18\u1962\u0001\u0000\u0000\u0000\u1a18\u1969"+ + "\u0001\u0000\u0000\u0000\u1a18\u1970\u0001\u0000\u0000\u0000\u1a18\u197a"+ + "\u0001\u0000\u0000\u0000\u1a18\u1984\u0001\u0000\u0000\u0000\u1a18\u198b"+ + "\u0001\u0000\u0000\u0000\u1a18\u1992\u0001\u0000\u0000\u0000\u1a18\u1999"+ + "\u0001\u0000\u0000\u0000\u1a18\u19a2\u0001\u0000\u0000\u0000\u1a18\u19a9"+ + "\u0001\u0000\u0000\u0000\u1a18\u19b2\u0001\u0000\u0000\u0000\u1a18\u19bb"+ + "\u0001\u0000\u0000\u0000\u1a18\u19c4\u0001\u0000\u0000\u0000\u1a18\u19cd"+ + "\u0001\u0000\u0000\u0000\u1a18\u19d4\u0001\u0000\u0000\u0000\u1a18\u19dd"+ + "\u0001\u0000\u0000\u0000\u1a18\u19e4\u0001\u0000\u0000\u0000\u1a18\u19ed"+ + "\u0001\u0000\u0000\u0000\u1a18\u19f5\u0001\u0000\u0000\u0000\u1a18\u19ff"+ + "\u0001\u0000\u0000\u0000\u1a18\u1a07\u0001\u0000\u0000\u0000\u1a18\u1a11"+ + "\u0001\u0000\u0000\u0000\u1a19\u02dd\u0001\u0000\u0000\u0000\u1a1a\u1a1b"+ + "\u0005\u008c\u0000\u0000\u1a1b\u1a1c\u0005\u0111\u0000\u0000\u1a1c\u1a1d"+ + "\u0003\u02b0\u0158\u0000\u1a1d\u1a1e\u0005\u0148\u0000\u0000\u1a1e\u1a1f"+ + "\u0005\u0003\u0000\u0000\u1a1f\u1a20\u0003\u02e0\u0170\u0000\u1a20\u1a21"+ + "\u0005\u0004\u0000\u0000\u1a21\u02df\u0001\u0000\u0000\u0000\u1a22\u1a27"+ + "\u0003\u02e2\u0171\u0000\u1a23\u1a24\u0005\u0007\u0000\u0000\u1a24\u1a26"+ + "\u0003\u02e2\u0171\u0000\u1a25\u1a23\u0001\u0000\u0000\u0000\u1a26\u1a29"+ + "\u0001\u0000\u0000\u0000\u1a27\u1a25\u0001\u0000\u0000\u0000\u1a27\u1a28"+ + "\u0001\u0000\u0000\u0000\u1a28\u02e1\u0001\u0000\u0000\u0000\u1a29\u1a27"+ + "\u0001\u0000\u0000\u0000\u1a2a\u1a2b\u0003\u0564\u02b2\u0000\u1a2b\u1a2c"+ + "\u0005\f\u0000\u0000\u1a2c\u1a2d\u0005\u0192\u0000\u0000\u1a2d\u1a33\u0001"+ + "\u0000\u0000\u0000\u1a2e\u1a2f\u0003\u0564\u02b2\u0000\u1a2f\u1a30\u0005"+ + "\f\u0000\u0000\u1a30\u1a31\u0003\u02e4\u0172\u0000\u1a31\u1a33\u0001\u0000"+ + "\u0000\u0000\u1a32\u1a2a\u0001\u0000\u0000\u0000\u1a32\u1a2e\u0001\u0000"+ + "\u0000\u0000\u1a33\u02e3\u0001\u0000\u0000\u0000\u1a34\u1a3a\u0003\u0280"+ + "\u0140\u0000\u1a35\u1a3a\u0003\u0570\u02b8\u0000\u1a36\u1a3a\u0003\u04fc"+ + "\u027e\u0000\u1a37\u1a3a\u0003\u0124\u0092\u0000\u1a38\u1a3a\u0003\u054e"+ + "\u02a7\u0000\u1a39\u1a34\u0001\u0000\u0000\u0000\u1a39\u1a35\u0001\u0000"+ + "\u0000\u0000\u1a39\u1a36\u0001\u0000\u0000\u0000\u1a39\u1a37\u0001\u0000"+ + "\u0000\u0000\u1a39\u1a38\u0001\u0000\u0000\u0000\u1a3a\u02e5\u0001\u0000"+ + "\u0000\u0000\u1a3b\u1a3c\u0005\u008c\u0000\u0000\u1a3c\u1a3d\u0005\u0163"+ + "\u0000\u0000\u1a3d\u1a3e\u0003\u020c\u0106\u0000\u1a3e\u1a3f\u0005\u0148"+ + "\u0000\u0000\u1a3f\u1a40\u0005\u0003\u0000\u0000\u1a40\u1a41\u0003\u02e0"+ + "\u0170\u0000\u1a41\u1a42\u0005\u0004\u0000\u0000\u1a42\u02e7\u0001\u0000"+ + "\u0000\u0000\u1a43\u1a44\u0005\u008c\u0000\u0000\u1a44\u1a45\u0005\u008a"+ + "\u0000\u0000\u1a45\u1a46\u0003\u028a\u0145\u0000\u1a46\u1a47\u0005\u0115"+ + "\u0000\u0000\u1a47\u1a48\u0005`\u0000\u0000\u1a48\u1a49\u0003\u0558\u02ac"+ + "\u0000\u1a49\u1afb\u0001\u0000\u0000\u0000\u1a4a\u1a4b\u0005\u008c\u0000"+ + "\u0000\u1a4b\u1a4c\u0005n\u0000\u0000\u1a4c\u1a4d\u0003\u020c\u0106\u0000"+ + "\u1a4d\u1a4e\u0005\u0115\u0000\u0000\u1a4e\u1a4f\u0005`\u0000\u0000\u1a4f"+ + "\u1a50\u0003\u0558\u02ac\u0000\u1a50\u1afb\u0001\u0000\u0000\u0000\u1a51"+ + "\u1a52\u0005\u008c\u0000\u0000\u1a52\u1a53\u0005\u00aa\u0000\u0000\u1a53"+ + "\u1a54\u0003\u020c\u0106\u0000\u1a54\u1a55\u0005\u0115\u0000\u0000\u1a55"+ + "\u1a56\u0005`\u0000\u0000\u1a56\u1a57\u0003\u0558\u02ac\u0000\u1a57\u1afb"+ + "\u0001\u0000\u0000\u0000\u1a58\u1a59\u0005\u008c\u0000\u0000\u1a59\u1a5a"+ + "\u0005\u00b1\u0000\u0000\u1a5a\u1a5b\u0003\u053c\u029e\u0000\u1a5b\u1a5c"+ + "\u0005\u0115\u0000\u0000\u1a5c\u1a5d\u0005`\u0000\u0000\u1a5d\u1a5e\u0003"+ + "\u0558\u02ac\u0000\u1a5e\u1afb\u0001\u0000\u0000\u0000\u1a5f\u1a60\u0005"+ + "\u008c\u0000\u0000\u1a60\u1a61\u0005\u00bf\u0000\u0000\u1a61\u1a62\u0003"+ + "\u020c\u0106\u0000\u1a62\u1a63\u0005\u0115\u0000\u0000\u1a63\u1a64\u0005"+ + "`\u0000\u0000\u1a64\u1a65\u0003\u0558\u02ac\u0000\u1a65\u1afb\u0001\u0000"+ + "\u0000\u0000\u1a66\u1a67\u0005\u008c\u0000\u0000\u1a67\u1a68\u0005\u00d5"+ + "\u0000\u0000\u1a68\u1a69\u0003\u0272\u0139\u0000\u1a69\u1a6a\u0005\u0115"+ + "\u0000\u0000\u1a6a\u1a6b\u0005`\u0000\u0000\u1a6b\u1a6c\u0003\u0558\u02ac"+ + "\u0000\u1a6c\u1afb\u0001\u0000\u0000\u0000\u1a6d\u1a6e\u0005\u008c\u0000"+ + "\u0000\u1a6e\u1a6f\u0003\u0134\u009a\u0000\u1a6f\u1a70\u0005\u00f0\u0000"+ + "\u0000\u1a70\u1a71\u0003\u053c\u029e\u0000\u1a71\u1a72\u0005\u0115\u0000"+ + "\u0000\u1a72\u1a73\u0005`\u0000\u0000\u1a73\u1a74\u0003\u0558\u02ac\u0000"+ + "\u1a74\u1afb\u0001\u0000\u0000\u0000\u1a75\u1a76\u0005\u008c\u0000\u0000"+ + "\u1a76\u1a77\u0005\u00f1\u0000\u0000\u1a77\u1a78\u0005\u010d\u0000\u0000"+ + "\u1a78\u1a79\u0003\u0124\u0092\u0000\u1a79\u1a7a\u0005\u0115\u0000\u0000"+ + "\u1a7a\u1a7b\u0005`\u0000\u0000\u1a7b\u1a7c\u0003\u0558\u02ac\u0000\u1a7c"+ + "\u1afb\u0001\u0000\u0000\u0000\u1a7d\u1a7e\u0005\u008c\u0000\u0000\u1a7e"+ + "\u1a7f\u0005\u0111\u0000\u0000\u1a7f\u1a80\u0003\u02b0\u0158\u0000\u1a80"+ + "\u1a81\u0005\u0115\u0000\u0000\u1a81\u1a82\u0005`\u0000\u0000\u1a82\u1a83"+ + "\u0003\u0558\u02ac\u0000\u1a83\u1afb\u0001\u0000\u0000\u0000\u1a84\u1a85"+ + "\u0005\u008c\u0000\u0000\u1a85\u1a86\u0005\u0111\u0000\u0000\u1a86\u1a87"+ + "\u0005\u009e\u0000\u0000\u1a87\u1a88\u0003\u020c\u0106\u0000\u1a88\u1a89"+ + "\u0005f\u0000\u0000\u1a89\u1a8a\u0003\u053c\u029e\u0000\u1a8a\u1a8b\u0005"+ + "\u0115\u0000\u0000\u1a8b\u1a8c\u0005`\u0000\u0000\u1a8c\u1a8d\u0003\u0558"+ + "\u02ac\u0000\u1a8d\u1afb\u0001\u0000\u0000\u0000\u1a8e\u1a8f\u0005\u008c"+ + "\u0000\u0000\u1a8f\u1a90\u0005\u0111\u0000\u0000\u1a90\u1a91\u0005\u00d0"+ + "\u0000\u0000\u1a91\u1a92\u0003\u020c\u0106\u0000\u1a92\u1a93\u0005f\u0000"+ + "\u0000\u1a93\u1a94\u0003\u053c\u029e\u0000\u1a94\u1a95\u0005\u0115\u0000"+ + "\u0000\u1a95\u1a96\u0005`\u0000\u0000\u1a96\u1a97\u0003\u0558\u02ac\u0000"+ + "\u1a97\u1afb\u0001\u0000\u0000\u0000\u1a98\u1a99\u0005\u008c\u0000\u0000"+ + "\u1a99\u1a9a\u0005\u0123\u0000\u0000\u1a9a\u1a9b\u0003\u0272\u0139\u0000"+ + "\u1a9b\u1a9c\u0005\u0115\u0000\u0000\u1a9c\u1a9d\u0005`\u0000\u0000\u1a9d"+ + "\u1a9e\u0003\u0558\u02ac\u0000\u1a9e\u1afb\u0001\u0000\u0000\u0000\u1a9f"+ + "\u1aa0\u0005\u008c\u0000\u0000\u1aa0\u1aa1\u0005\u01bc\u0000\u0000\u1aa1"+ + "\u1aa2\u0003\u0272\u0139\u0000\u1aa2\u1aa3\u0005\u0115\u0000\u0000\u1aa3"+ + "\u1aa4\u0005`\u0000\u0000\u1aa4\u1aa5\u0003\u0558\u02ac\u0000\u1aa5\u1afb"+ + "\u0001\u0000\u0000\u0000\u1aa6\u1aa7\u0005\u008c\u0000\u0000\u1aa7\u1aa8"+ + "\u0005\u013e\u0000\u0000\u1aa8\u1aa9\u0003\u053c\u029e\u0000\u1aa9\u1aaa"+ + "\u0005\u0115\u0000\u0000\u1aaa\u1aab\u0005`\u0000\u0000\u1aab\u1aac\u0003"+ + "\u0558\u02ac\u0000\u1aac\u1afb\u0001\u0000\u0000\u0000\u1aad\u1aae\u0005"+ + "\u008c\u0000\u0000\u1aae\u1aaf\u0005\u0163\u0000\u0000\u1aaf\u1ab0\u0003"+ + "\u020c\u0106\u0000\u1ab0\u1ab1\u0005\u0115\u0000\u0000\u1ab1\u1ab2\u0005"+ + "`\u0000\u0000\u1ab2\u1ab3\u0003\u0558\u02ac\u0000\u1ab3\u1afb\u0001\u0000"+ + "\u0000\u0000\u1ab4\u1ab5\u0005\u008c\u0000\u0000\u1ab5\u1ab6\u0005\u015a"+ + "\u0000\u0000\u1ab6\u1ab7\u0003\u053c\u029e\u0000\u1ab7\u1ab8\u0005\u0115"+ + "\u0000\u0000\u1ab8\u1ab9\u0005`\u0000\u0000\u1ab9\u1aba\u0003\u0558\u02ac"+ + "\u0000\u1aba\u1afb\u0001\u0000\u0000\u0000\u1abb\u1abc\u0005\u008c\u0000"+ + "\u0000\u1abc\u1abd\u0005\u0151\u0000\u0000\u1abd\u1abe\u0003\u020c\u0106"+ + "\u0000\u1abe\u1abf\u0005\u0115\u0000\u0000\u1abf\u1ac0\u0005`\u0000\u0000"+ + "\u1ac0\u1ac1\u0003\u0558\u02ac\u0000\u1ac1\u1afb\u0001\u0000\u0000\u0000"+ + "\u1ac2\u1ac3\u0005\u008c\u0000\u0000\u1ac3\u1ac4\u0005\u015e\u0000\u0000"+ + "\u1ac4\u1ac5\u0005\u0140\u0000\u0000\u1ac5\u1ac6\u0005\u00bb\u0000\u0000"+ + "\u1ac6\u1ac7\u0003\u020c\u0106\u0000\u1ac7\u1ac8\u0005\u0115\u0000\u0000"+ + "\u1ac8\u1ac9\u0005`\u0000\u0000\u1ac9\u1aca\u0003\u0558\u02ac\u0000\u1aca"+ + "\u1afb\u0001\u0000\u0000\u0000\u1acb\u1acc\u0005\u008c\u0000\u0000\u1acc"+ + "\u1acd\u0005\u015e\u0000\u0000\u1acd\u1ace\u0005\u0140\u0000\u0000\u1ace"+ + "\u1acf\u0005\u00a5\u0000\u0000\u1acf\u1ad0\u0003\u020c\u0106\u0000\u1ad0"+ + "\u1ad1\u0005\u0115\u0000\u0000\u1ad1\u1ad2\u0005`\u0000\u0000\u1ad2\u1ad3"+ + "\u0003\u0558\u02ac\u0000\u1ad3\u1afb\u0001\u0000\u0000\u0000\u1ad4\u1ad5"+ + "\u0005\u008c\u0000\u0000\u1ad5\u1ad6\u0005A\u0000\u0000\u1ad6\u1ad7\u0005"+ + "\u00b0\u0000\u0000\u1ad7\u1ad8\u0005\u0178\u0000\u0000\u1ad8\u1ad9\u0003"+ + "\u053c\u029e\u0000\u1ad9\u1ada\u0005\u0115\u0000\u0000\u1ada\u1adb\u0005"+ + "`\u0000\u0000\u1adb\u1adc\u0003\u0558\u02ac\u0000\u1adc\u1afb\u0001\u0000"+ + "\u0000\u0000\u1add\u1ade\u0005\u008c\u0000\u0000\u1ade\u1adf\u0005\u0146"+ + "\u0000\u0000\u1adf\u1ae0\u0003\u053c\u029e\u0000\u1ae0\u1ae1\u0005\u0115"+ + "\u0000\u0000\u1ae1\u1ae2\u0005`\u0000\u0000\u1ae2\u1ae3\u0003\u0558\u02ac"+ + "\u0000\u1ae3\u1afb\u0001\u0000\u0000\u0000\u1ae4\u1ae5\u0005\u008c\u0000"+ + "\u0000\u1ae5\u1ae6\u0005\u00c8\u0000\u0000\u1ae6\u1ae7\u0005\u0160\u0000"+ + "\u0000\u1ae7\u1ae8\u0003\u053c\u029e\u0000\u1ae8\u1ae9\u0005\u0115\u0000"+ + "\u0000\u1ae9\u1aea\u0005`\u0000\u0000\u1aea\u1aeb\u0003\u0558\u02ac\u0000"+ + "\u1aeb\u1afb\u0001\u0000\u0000\u0000\u1aec\u1aed\u0005\u008c\u0000\u0000"+ + "\u1aed\u1aee\u0005\u01c6\u0000\u0000\u1aee\u1aef\u0003\u053c\u029e\u0000"+ + "\u1aef\u1af0\u0005\u0115\u0000\u0000\u1af0\u1af1\u0005`\u0000\u0000\u1af1"+ + "\u1af2\u0003\u0558\u02ac\u0000\u1af2\u1afb\u0001\u0000\u0000\u0000\u1af3"+ + "\u1af4\u0005\u008c\u0000\u0000\u1af4\u1af5\u0005\u01c5\u0000\u0000\u1af5"+ + "\u1af6\u0003\u053c\u029e\u0000\u1af6\u1af7\u0005\u0115\u0000\u0000\u1af7"+ + "\u1af8\u0005`\u0000\u0000\u1af8\u1af9\u0003\u0558\u02ac\u0000\u1af9\u1afb"+ + "\u0001\u0000\u0000\u0000\u1afa\u1a43\u0001\u0000\u0000\u0000\u1afa\u1a4a"+ + "\u0001\u0000\u0000\u0000\u1afa"; + private static final String _serializedATNSegment3 = + "\u1a51\u0001\u0000\u0000\u0000\u1afa\u1a58\u0001\u0000\u0000\u0000\u1afa"+ + "\u1a5f\u0001\u0000\u0000\u0000\u1afa\u1a66\u0001\u0000\u0000\u0000\u1afa"+ + "\u1a6d\u0001\u0000\u0000\u0000\u1afa\u1a75\u0001\u0000\u0000\u0000\u1afa"+ + "\u1a7d\u0001\u0000\u0000\u0000\u1afa\u1a84\u0001\u0000\u0000\u0000\u1afa"+ + "\u1a8e\u0001\u0000\u0000\u0000\u1afa\u1a98\u0001\u0000\u0000\u0000\u1afa"+ + "\u1a9f\u0001\u0000\u0000\u0000\u1afa\u1aa6\u0001\u0000\u0000\u0000\u1afa"+ + "\u1aad\u0001\u0000\u0000\u0000\u1afa\u1ab4\u0001\u0000\u0000\u0000\u1afa"+ + "\u1abb\u0001\u0000\u0000\u0000\u1afa\u1ac2\u0001\u0000\u0000\u0000\u1afa"+ + "\u1acb\u0001\u0000\u0000\u0000\u1afa\u1ad4\u0001\u0000\u0000\u0000\u1afa"+ + "\u1add\u0001\u0000\u0000\u0000\u1afa\u1ae4\u0001\u0000\u0000\u0000\u1afa"+ + "\u1aec\u0001\u0000\u0000\u0000\u1afa\u1af3\u0001\u0000\u0000\u0000\u1afb"+ + "\u02e9\u0001\u0000\u0000\u0000\u1afc\u1afd\u00050\u0000\u0000\u1afd\u1afe"+ + "\u0005\u01c6\u0000\u0000\u1afe\u1aff\u0003\u053c\u029e\u0000\u1aff\u1b00"+ + "\u0003\u02ec\u0176\u0000\u1b00\u1b01\u0003\u0298\u014c\u0000\u1b01\u02eb"+ + "\u0001\u0000\u0000\u0000\u1b02\u1b05\u0003\u02ee\u0177\u0000\u1b03\u1b05"+ + "\u0001\u0000\u0000\u0000\u1b04\u1b02\u0001\u0000\u0000\u0000\u1b04\u1b03"+ + "\u0001\u0000\u0000\u0000\u1b05\u02ed\u0001\u0000\u0000\u0000\u1b06\u1b07"+ + "\u0005@\u0000\u0000\u1b07\u1b08\u0005^\u0000\u0000\u1b08\u1b0d\u0003\u0436"+ + "\u021b\u0000\u1b09\u1b0a\u0005@\u0000\u0000\u1b0a\u1b0b\u0005 \u0000\u0000"+ + "\u1b0b\u1b0d\u0005\u0159\u0000\u0000\u1b0c\u1b06\u0001\u0000\u0000\u0000"+ + "\u1b0c\u1b09\u0001\u0000\u0000\u0000\u1b0d\u02ef\u0001\u0000\u0000\u0000"+ + "\u1b0e\u1b0f\u0005\u008c\u0000\u0000\u1b0f\u1b10\u0005\u01c6\u0000\u0000"+ + "\u1b10\u1b11\u0003\u053c\u029e\u0000\u1b11\u1b12\u0005\u0148\u0000\u0000"+ + "\u1b12\u1b13\u0003\u01cc\u00e6\u0000\u1b13\u1b2a\u0001\u0000\u0000\u0000"+ + "\u1b14\u1b15\u0005\u008c\u0000\u0000\u1b15\u1b16\u0005\u01c6\u0000\u0000"+ + "\u1b16\u1b17\u0003\u053c\u029e\u0000\u1b17\u1b18\u0005\u0087\u0000\u0000"+ + "\u1b18\u1b19\u0005^\u0000\u0000\u1b19\u1b1a\u0003\u0436\u021b\u0000\u1b1a"+ + "\u1b2a\u0001\u0000\u0000\u0000\u1b1b\u1b1c\u0005\u008c\u0000\u0000\u1b1c"+ + "\u1b1d\u0005\u01c6\u0000\u0000\u1b1d\u1b1e\u0003\u053c\u029e\u0000\u1b1e"+ + "\u1b1f\u0005\u0148\u0000\u0000\u1b1f\u1b20\u0005^\u0000\u0000\u1b20\u1b21"+ + "\u0003\u0436\u021b\u0000\u1b21\u1b2a\u0001\u0000\u0000\u0000\u1b22\u1b23"+ + "\u0005\u008c\u0000\u0000\u1b23\u1b24\u0005\u01c6\u0000\u0000\u1b24\u1b25"+ + "\u0003\u053c\u029e\u0000\u1b25\u1b26\u0005\u00c1\u0000\u0000\u1b26\u1b27"+ + "\u0005^\u0000\u0000\u1b27\u1b28\u0003\u0436\u021b\u0000\u1b28\u1b2a\u0001"+ + "\u0000\u0000\u0000\u1b29\u1b0e\u0001\u0000\u0000\u0000\u1b29\u1b14\u0001"+ + "\u0000\u0000\u0000\u1b29\u1b1b\u0001\u0000\u0000\u0000\u1b29\u1b22\u0001"+ + "\u0000\u0000\u0000\u1b2a\u02f1\u0001\u0000\u0000\u0000\u1b2b\u1b2c\u0005"+ + "0\u0000\u0000\u1b2c\u1b2d\u0005\u01c5\u0000\u0000\u1b2d\u1b2e\u0003\u053c"+ + "\u029e\u0000\u1b2e\u1b2f\u0005\u00a6\u0000\u0000\u1b2f\u1b30\u0003\u054e"+ + "\u02a7\u0000\u1b30\u1b31\u0005\u01c6\u0000\u0000\u1b31\u1b32\u0003\u02f4"+ + "\u017a\u0000\u1b32\u1b33\u0003\u0298\u014c\u0000\u1b33\u02f3\u0001\u0000"+ + "\u0000\u0000\u1b34\u1b39\u0003\u02f6\u017b\u0000\u1b35\u1b36\u0005\u0007"+ + "\u0000\u0000\u1b36\u1b38\u0003\u02f6\u017b\u0000\u1b37\u1b35\u0001\u0000"+ + "\u0000\u0000\u1b38\u1b3b\u0001\u0000\u0000\u0000\u1b39\u1b37\u0001\u0000"+ + "\u0000\u0000\u1b39\u1b3a\u0001\u0000\u0000\u0000\u1b3a\u02f5\u0001\u0000"+ + "\u0000\u0000\u1b3b\u1b39\u0001\u0000\u0000\u0000\u1b3c\u1b3d\u0003\u0564"+ + "\u02b2\u0000\u1b3d\u02f7\u0001\u0000\u0000\u0000\u1b3e\u1b3f\u0005\u008c"+ + "\u0000\u0000\u1b3f\u1b40\u0005\u01c5\u0000\u0000\u1b40\u1b41\u0003\u053c"+ + "\u029e\u0000\u1b41\u1b42\u0005\u0148\u0000\u0000\u1b42\u1b43\u0003\u01cc"+ + "\u00e6\u0000\u1b43\u1b64\u0001\u0000\u0000\u0000\u1b44\u1b45\u0005\u008c"+ + "\u0000\u0000\u1b45\u1b46\u0005\u01c5\u0000\u0000\u1b46\u1b47\u0003\u053c"+ + "\u029e\u0000\u1b47\u1b48\u0005\u00a6\u0000\u0000\u1b48\u1b49\u0003\u054e"+ + "\u02a7\u0000\u1b49\u1b64\u0001\u0000\u0000\u0000\u1b4a\u1b4b\u0005\u008c"+ + "\u0000\u0000\u1b4b\u1b4c\u0005\u01c5\u0000\u0000\u1b4c\u1b4d\u0003\u053c"+ + "\u029e\u0000\u1b4d\u1b4e\u0005\u012c\u0000\u0000\u1b4e\u1b4f\u0005\u01c6"+ + "\u0000\u0000\u1b4f\u1b50\u0003\u0298\u014c\u0000\u1b50\u1b64\u0001\u0000"+ + "\u0000\u0000\u1b51\u1b52\u0005\u008c\u0000\u0000\u1b52\u1b53\u0005\u01c5"+ + "\u0000\u0000\u1b53\u1b54\u0003\u053c\u029e\u0000\u1b54\u1b55\u0005\u0148"+ + "\u0000\u0000\u1b55\u1b56\u0005\u01c6\u0000\u0000\u1b56\u1b57\u0003\u02f4"+ + "\u017a\u0000\u1b57\u1b58\u0003\u0298\u014c\u0000\u1b58\u1b64\u0001\u0000"+ + "\u0000\u0000\u1b59\u1b5a\u0005\u008c\u0000\u0000\u1b5a\u1b5b\u0005\u01c5"+ + "\u0000\u0000\u1b5b\u1b5c\u0003\u053c\u029e\u0000\u1b5c\u1b5d\u0005\u00c3"+ + "\u0000\u0000\u1b5d\u1b64\u0001\u0000\u0000\u0000\u1b5e\u1b5f\u0005\u008c"+ + "\u0000\u0000\u1b5f\u1b60\u0005\u01c5\u0000\u0000\u1b60\u1b61\u0003\u053c"+ + "\u029e\u0000\u1b61\u1b62\u0005\u00bc\u0000\u0000\u1b62\u1b64\u0001\u0000"+ + "\u0000\u0000\u1b63\u1b3e\u0001\u0000\u0000\u0000\u1b63\u1b44\u0001\u0000"+ + "\u0000\u0000\u1b63\u1b4a\u0001\u0000\u0000\u0000\u1b63\u1b51\u0001\u0000"+ + "\u0000\u0000\u1b63\u1b59\u0001\u0000\u0000\u0000\u1b63\u1b5e\u0001\u0000"+ + "\u0000\u0000\u1b64\u02f9\u0001\u0000\u0000\u0000\u1b65\u1b66\u0005\u00c1"+ + "\u0000\u0000\u1b66\u1b67\u0005\u01c5\u0000\u0000\u1b67\u1b68\u0003\u053c"+ + "\u029e\u0000\u1b68\u1b69\u0003l6\u0000\u1b69\u1b72\u0001\u0000\u0000\u0000"+ + "\u1b6a\u1b6b\u0005\u00c1\u0000\u0000\u1b6b\u1b6c\u0005\u01c5\u0000\u0000"+ + "\u1b6c\u1b6d\u0005\u00de\u0000\u0000\u1b6d\u1b6e\u0005\u0187\u0000\u0000"+ + "\u1b6e\u1b6f\u0003\u053c\u029e\u0000\u1b6f\u1b70\u0003l6\u0000\u1b70\u1b72"+ + "\u0001\u0000\u0000\u0000\u1b71\u1b65\u0001\u0000\u0000\u0000\u1b71\u1b6a"+ + "\u0001\u0000\u0000\u0000\u1b72\u02fb\u0001\u0000\u0000\u0000\u1b73\u1b74"+ + "\u00050\u0000\u0000\u1b74\u1b75\u0003\u026a\u0135\u0000\u1b75\u1b76\u0005"+ + "\u013c\u0000\u0000\u1b76\u1b77\u0003\u053c\u029e\u0000\u1b77\u1b78\u0005"+ + "&\u0000\u0000\u1b78\u1b79\u0005R\u0000\u0000\u1b79\u1b7a\u0003\u0306\u0183"+ + "\u0000\u1b7a\u1b7b\u0005`\u0000\u0000\u1b7b\u1b7c\u0003\u0538\u029c\u0000"+ + "\u1b7c\u1b7d\u0003\u0448\u0224\u0000\u1b7d\u1b7e\u0005;\u0000\u0000\u1b7e"+ + "\u1b7f\u0003\u0308\u0184\u0000\u1b7f\u1b80\u0003\u02fe\u017f\u0000\u1b80"+ + "\u02fd\u0001\u0000\u0000\u0000\u1b81\u1b88\u0005\u0109\u0000\u0000\u1b82"+ + "\u1b88\u0003\u0302\u0181\u0000\u1b83\u1b84\u0005\u0003\u0000\u0000\u1b84"+ + "\u1b85\u0003\u0300\u0180\u0000\u1b85\u1b86\u0005\u0004\u0000\u0000\u1b86"+ + "\u1b88\u0001\u0000\u0000\u0000\u1b87\u1b81\u0001\u0000\u0000\u0000\u1b87"+ + "\u1b82\u0001\u0000\u0000\u0000\u1b87\u1b83\u0001\u0000\u0000\u0000\u1b88"+ + "\u02ff\u0001\u0000\u0000\u0000\u1b89\u1b8e\u0003\u0304\u0182\u0000\u1b8a"+ + "\u1b8b\u0005\b\u0000\u0000\u1b8b\u1b8d\u0003\u0304\u0182\u0000\u1b8c\u1b8a"+ + "\u0001\u0000\u0000\u0000\u1b8d\u1b90\u0001\u0000\u0000\u0000\u1b8e\u1b8c"+ + "\u0001\u0000\u0000\u0000\u1b8e\u1b8f\u0001\u0000\u0000\u0000\u1b8f\u0301"+ + "\u0001\u0000\u0000\u0000\u1b90\u1b8e\u0001\u0000\u0000\u0000\u1b91\u1b97"+ + "\u0003\u03c0\u01e0\u0000\u1b92\u1b97\u0003\u0386\u01c3\u0000\u1b93\u1b97"+ + "\u0003\u03ae\u01d7\u0000\u1b94\u1b97\u0003\u03a0\u01d0\u0000\u1b95\u1b97"+ + "\u0003\u030a\u0185\u0000\u1b96\u1b91\u0001\u0000\u0000\u0000\u1b96\u1b92"+ + "\u0001\u0000\u0000\u0000\u1b96\u1b93\u0001\u0000\u0000\u0000\u1b96\u1b94"+ + "\u0001\u0000\u0000\u0000\u1b96\u1b95\u0001\u0000\u0000\u0000\u1b97\u0303"+ + "\u0001\u0000\u0000\u0000\u1b98\u1b9b\u0003\u0302\u0181\u0000\u1b99\u1b9b"+ + "\u0001\u0000\u0000\u0000\u1b9a\u1b98\u0001\u0000\u0000\u0000\u1b9a\u1b99"+ + "\u0001\u0000\u0000\u0000\u1b9b\u0305\u0001\u0000\u0000\u0000\u1b9c\u1b9d"+ + "\u0007\u001f\u0000\u0000\u1b9d\u0307\u0001\u0000\u0000\u0000\u1b9e\u1ba2"+ + "\u0005\u00eb\u0000\u0000\u1b9f\u1ba2\u0005\u008b\u0000\u0000\u1ba0\u1ba2"+ + "\u0001\u0000\u0000\u0000\u1ba1\u1b9e\u0001\u0000\u0000\u0000\u1ba1\u1b9f"+ + "\u0001\u0000\u0000\u0000\u1ba1\u1ba0\u0001\u0000\u0000\u0000\u1ba2\u0309"+ + "\u0001\u0000\u0000\u0000\u1ba3\u1ba4\u0005\u010a\u0000\u0000\u1ba4\u1ba5"+ + "\u0003\u055c\u02ae\u0000\u1ba5\u1ba6\u0003\u030c\u0186\u0000\u1ba6\u030b"+ + "\u0001\u0000\u0000\u0000\u1ba7\u1ba8\u0005\u0007\u0000\u0000\u1ba8\u1bab"+ + "\u0003\u054e\u02a7\u0000\u1ba9\u1bab\u0001\u0000\u0000\u0000\u1baa\u1ba7"+ + "\u0001\u0000\u0000\u0000\u1baa\u1ba9\u0001\u0000\u0000\u0000\u1bab\u030d"+ + "\u0001\u0000\u0000\u0000\u1bac\u1bad\u0005\u00f5\u0000\u0000\u1bad\u1bae"+ + "\u0003\u055c\u02ae\u0000\u1bae\u030f\u0001\u0000\u0000\u0000\u1baf\u1bb0"+ + "\u0005\u0169\u0000\u0000\u1bb0\u1bb4\u0003\u055c\u02ae\u0000\u1bb1\u1bb2"+ + "\u0005\u0169\u0000\u0000\u1bb2\u1bb4\u0005\u000b\u0000\u0000\u1bb3\u1baf"+ + "\u0001\u0000\u0000\u0000\u1bb3\u1bb1\u0001\u0000\u0000\u0000\u1bb4\u0311"+ + "\u0001\u0000\u0000\u0000\u1bb5\u1bb6\u0005\u0083\u0000\u0000\u1bb6\u1bb7"+ + "\u0003\u0314\u018a\u0000\u1bb7\u1bb8\u0003\u031c\u018e\u0000\u1bb8\u1be8"+ + "\u0001\u0000\u0000\u0000\u1bb9\u1bba\u0005\u0094\u0000\u0000\u1bba\u1bbb"+ + "\u0003\u0314\u018a\u0000\u1bbb\u1bbc\u0003\u031a\u018d\u0000\u1bbc\u1be8"+ + "\u0001\u0000\u0000\u0000\u1bbd\u1bbe\u0005\u014f\u0000\u0000\u1bbe\u1bbf"+ + "\u0005\u015f\u0000\u0000\u1bbf\u1be8\u0003\u031a\u018d\u0000\u1bc0\u1bc1"+ + "\u0005\u00a3\u0000\u0000\u1bc1\u1bc2\u0003\u0314\u018a\u0000\u1bc2\u1bc3"+ + "\u0003\u031c\u018e\u0000\u1bc3\u1be8\u0001\u0000\u0000\u0000\u1bc4\u1bc5"+ + "\u0005\u01c8\u0000\u0000\u1bc5\u1bc6\u0003\u0314\u018a\u0000\u1bc6\u1bc7"+ + "\u0003\u031c\u018e\u0000\u1bc7\u1be8\u0001\u0000\u0000\u0000\u1bc8\u1bc9"+ + "\u0005\u013a\u0000\u0000\u1bc9\u1bca\u0003\u0314\u018a\u0000\u1bca\u1bcb"+ + "\u0003\u031c\u018e\u0000\u1bcb\u1be8\u0001\u0000\u0000\u0000\u1bcc\u1bcd"+ + "\u0005\u013d\u0000\u0000\u1bcd\u1be8\u0003\u055c\u02ae\u0000\u1bce\u1bcf"+ + "\u0005\u012f\u0000\u0000\u1bcf\u1bd0\u0005\u013d\u0000\u0000\u1bd0\u1be8"+ + "\u0003\u055c\u02ae\u0000\u1bd1\u1bd2\u0005\u012f\u0000\u0000\u1bd2\u1be8"+ + "\u0003\u055c\u02ae\u0000\u1bd3\u1bd4\u0005\u013a\u0000\u0000\u1bd4\u1bd5"+ + "\u0003\u0314\u018a\u0000\u1bd5\u1bd6\u0005`\u0000\u0000\u1bd6\u1bd7\u0005"+ + "\u013d\u0000\u0000\u1bd7\u1bd8\u0003\u055c\u02ae\u0000\u1bd8\u1be8\u0001"+ + "\u0000\u0000\u0000\u1bd9\u1bda\u0005\u013a\u0000\u0000\u1bda\u1bdb\u0003"+ + "\u0314\u018a\u0000\u1bdb\u1bdc\u0005`\u0000\u0000\u1bdc\u1bdd\u0003\u055c"+ + "\u02ae\u0000\u1bdd\u1be8\u0001\u0000\u0000\u0000\u1bde\u1bdf\u0005\u011d"+ + "\u0000\u0000\u1bdf\u1be0\u0005\u015f\u0000\u0000\u1be0\u1be8\u0003\u054e"+ + "\u02a7\u0000\u1be1\u1be2\u0005\u00a3\u0000\u0000\u1be2\u1be3\u0005\u011e"+ + "\u0000\u0000\u1be3\u1be8\u0003\u054e\u02a7\u0000\u1be4\u1be5\u0005\u013a"+ + "\u0000\u0000\u1be5\u1be6\u0005\u011e\u0000\u0000\u1be6\u1be8\u0003\u054e"+ + "\u02a7\u0000\u1be7\u1bb5\u0001\u0000\u0000\u0000\u1be7\u1bb9\u0001\u0000"+ + "\u0000\u0000\u1be7\u1bbd\u0001\u0000\u0000\u0000\u1be7\u1bc0\u0001\u0000"+ + "\u0000\u0000\u1be7\u1bc4\u0001\u0000\u0000\u0000\u1be7\u1bc8\u0001\u0000"+ + "\u0000\u0000\u1be7\u1bcc\u0001\u0000\u0000\u0000\u1be7\u1bce\u0001\u0000"+ + "\u0000\u0000\u1be7\u1bd1\u0001\u0000\u0000\u0000\u1be7\u1bd3\u0001\u0000"+ + "\u0000\u0000\u1be7\u1bd9\u0001\u0000\u0000\u0000\u1be7\u1bde\u0001\u0000"+ + "\u0000\u0000\u1be7\u1be1\u0001\u0000\u0000\u0000\u1be7\u1be4\u0001\u0000"+ + "\u0000\u0000\u1be8\u0313\u0001\u0000\u0000\u0000\u1be9\u1bed\u0005\u0177"+ + "\u0000\u0000\u1bea\u1bed\u0005\u015f\u0000\u0000\u1beb\u1bed\u0001\u0000"+ + "\u0000\u0000\u1bec\u1be9\u0001\u0000\u0000\u0000\u1bec\u1bea\u0001\u0000"+ + "\u0000\u0000\u1bec\u1beb\u0001\u0000\u0000\u0000\u1bed\u0315\u0001\u0000"+ + "\u0000\u0000\u1bee\u1bef\u0005\u00ed\u0000\u0000\u1bef\u1bf0\u0005\u00f4"+ + "\u0000\u0000\u1bf0\u1bf9\u0003@ \u0000\u1bf1\u1bf2\u0005\u0127\u0000\u0000"+ + "\u1bf2\u1bf9\u0005S\u0000\u0000\u1bf3\u1bf4\u0005\u0127\u0000\u0000\u1bf4"+ + "\u1bf9\u0005\u0179\u0000\u0000\u1bf5\u1bf9\u00058\u0000\u0000\u1bf6\u1bf7"+ + "\u0005O\u0000\u0000\u1bf7\u1bf9\u00058\u0000\u0000\u1bf8\u1bee\u0001\u0000"+ + "\u0000\u0000\u1bf8\u1bf1\u0001\u0000\u0000\u0000\u1bf8\u1bf3\u0001\u0000"+ + "\u0000\u0000\u1bf8\u1bf5\u0001\u0000\u0000\u0000\u1bf8\u1bf6\u0001\u0000"+ + "\u0000\u0000\u1bf9\u0317\u0001\u0000\u0000\u0000\u1bfa\u1c01\u0003\u0316"+ + "\u018b\u0000\u1bfb\u1bfd\u0005\u0007\u0000\u0000\u1bfc\u1bfb\u0001\u0000"+ + "\u0000\u0000\u1bfc\u1bfd\u0001\u0000\u0000\u0000\u1bfd\u1bfe\u0001\u0000"+ + "\u0000\u0000\u1bfe\u1c00\u0003\u0316\u018b\u0000\u1bff\u1bfc\u0001\u0000"+ + "\u0000\u0000\u1c00\u1c03\u0001\u0000\u0000\u0000\u1c01\u1bff\u0001\u0000"+ + "\u0000\u0000\u1c01\u1c02\u0001\u0000\u0000\u0000\u1c02\u0319\u0001\u0000"+ + "\u0000\u0000\u1c03\u1c01\u0001\u0000\u0000\u0000\u1c04\u1c07\u0003\u0318"+ + "\u018c\u0000\u1c05\u1c07\u0001\u0000\u0000\u0000\u1c06\u1c04\u0001\u0000"+ + "\u0000\u0000\u1c06\u1c05\u0001\u0000\u0000\u0000\u1c07\u031b\u0001\u0000"+ + "\u0000\u0000\u1c08\u1c0a\u0005#\u0000\u0000\u1c09\u1c0b\u0005\u0108\u0000"+ + "\u0000\u1c0a\u1c09\u0001\u0000\u0000\u0000\u1c0a\u1c0b\u0001\u0000\u0000"+ + "\u0000\u1c0b\u1c0c\u0001\u0000\u0000\u0000\u1c0c\u1c0f\u0005\u009b\u0000"+ + "\u0000\u1c0d\u1c0f\u0001\u0000\u0000\u0000\u1c0e\u1c08\u0001\u0000\u0000"+ + "\u0000\u1c0e\u1c0d\u0001\u0000\u0000\u0000\u1c0f\u031d\u0001\u0000\u0000"+ + "\u0000\u1c10\u1c13\u00050\u0000\u0000\u1c11\u1c12\u0005T\u0000\u0000\u1c12"+ + "\u1c14\u0005\u0132\u0000\u0000\u1c13\u1c11\u0001\u0000\u0000\u0000\u1c13"+ + "\u1c14\u0001\u0000\u0000\u0000\u1c14\u1c15\u0001\u0000\u0000\u0000\u1c15"+ + "\u1c23\u0003\u00aeW\u0000\u1c16\u1c17\u0005\u0173\u0000\u0000\u1c17\u1c18"+ + "\u0003\u0538\u029c\u0000\u1c18\u1c19\u0003\u00d6k\u0000\u1c19\u1c1a\u0003"+ + "v;\u0000\u1c1a\u1c24\u0001\u0000\u0000\u0000\u1c1b\u1c1c\u0005\u012a\u0000"+ + "\u0000\u1c1c\u1c1d\u0005\u0173\u0000\u0000\u1c1d\u1c1e\u0003\u0538\u029c"+ + "\u0000\u1c1e\u1c1f\u0005\u0003\u0000\u0000\u1c1f\u1c20\u0003\u00d8l\u0000"+ + "\u1c20\u1c21\u0005\u0004\u0000\u0000\u1c21\u1c22\u0003v;\u0000\u1c22\u1c24"+ + "\u0001\u0000\u0000\u0000\u1c23\u1c16\u0001\u0000\u0000\u0000\u1c23\u1c1b"+ + "\u0001\u0000\u0000\u0000\u1c24\u1c25\u0001\u0000\u0000\u0000\u1c25\u1c26"+ + "\u0005&\u0000\u0000\u1c26\u1c27\u0003\u03c0\u01e0\u0000\u1c27\u1c28\u0003"+ + "\u0320\u0190\u0000\u1c28\u031f\u0001\u0000\u0000\u0000\u1c29\u1c2b\u0005"+ + "k\u0000\u0000\u1c2a\u1c2c\u0007 \u0000\u0000\u1c2b\u1c2a\u0001\u0000\u0000"+ + "\u0000\u1c2b\u1c2c\u0001\u0000\u0000\u0000\u1c2c\u1c2d\u0001\u0000\u0000"+ + "\u0000\u1c2d\u1c2e\u0005,\u0000\u0000\u1c2e\u1c31\u0005\u0112\u0000\u0000"+ + "\u1c2f\u1c31\u0001\u0000\u0000\u0000\u1c30\u1c29\u0001\u0000\u0000\u0000"+ + "\u1c30\u1c2f\u0001\u0000\u0000\u0000\u1c31\u0321\u0001\u0000\u0000\u0000"+ + "\u1c32\u1c33\u0005\u00f6\u0000\u0000\u1c33\u1c34\u0003\u0540\u02a0\u0000"+ + "\u1c34\u0323\u0001\u0000\u0000\u0000\u1c35\u1c36\u00050\u0000\u0000\u1c36"+ + "\u1c37\u0005\u00b1\u0000\u0000\u1c37\u1c38\u0003\u053c\u029e\u0000\u1c38"+ + "\u1c39\u0003\u0010\b\u0000\u1c39\u1c3a\u0003\u0326\u0193\u0000\u1c3a\u0325"+ + "\u0001\u0000\u0000\u0000\u1c3b\u1c3e\u0003\u0328\u0194\u0000\u1c3c\u1c3e"+ + "\u0001\u0000\u0000\u0000\u1c3d\u1c3b\u0001\u0000\u0000\u0000\u1c3d\u1c3c"+ + "\u0001\u0000\u0000\u0000\u1c3e\u0327\u0001\u0000\u0000\u0000\u1c3f\u1c41"+ + "\u0003\u032a\u0195\u0000\u1c40\u1c3f\u0001\u0000\u0000\u0000\u1c41\u1c42"+ + "\u0001\u0000\u0000\u0000\u1c42\u1c40\u0001\u0000\u0000\u0000\u1c42\u1c43"+ + "\u0001\u0000\u0000\u0000\u1c43\u0329\u0001\u0000\u0000\u0000\u1c44\u1c45"+ + "\u0003\u032c\u0196\u0000\u1c45\u1c49\u0003\u032e\u0197\u0000\u1c46\u1c4a"+ + "\u0003\u0554\u02aa\u0000\u1c47\u1c4a\u0003B!\u0000\u1c48\u1c4a\u00057"+ + "\u0000\u0000\u1c49\u1c46\u0001\u0000\u0000\u0000\u1c49\u1c47\u0001\u0000"+ + "\u0000\u0000\u1c49\u1c48\u0001\u0000\u0000\u0000\u1c4a\u032b\u0001\u0000"+ + "\u0000\u0000\u1c4b\u1c54\u0003\u0566\u02b3\u0000\u1c4c\u1c4d\u0005\u00a6"+ + "\u0000\u0000\u1c4d\u1c54\u0005L\u0000\u0000\u1c4e\u1c54\u0005\u00c4\u0000"+ + "\u0000\u1c4f\u1c54\u0005\u00f8\u0000\u0000\u1c50\u1c54\u0005\u0115\u0000"+ + "\u0000\u1c51\u1c54\u0005\u015a\u0000\u0000\u1c52\u1c54\u0005\u015c\u0000"+ + "\u0000\u1c53\u1c4b\u0001\u0000\u0000\u0000\u1c53\u1c4c\u0001\u0000\u0000"+ + "\u0000\u1c53\u1c4e\u0001\u0000\u0000\u0000\u1c53\u1c4f\u0001\u0000\u0000"+ + "\u0000\u1c53\u1c50\u0001\u0000\u0000\u0000\u1c53\u1c51\u0001\u0000\u0000"+ + "\u0000\u1c53\u1c52\u0001\u0000\u0000\u0000\u1c54\u032d\u0001\u0000\u0000"+ + "\u0000\u1c55\u1c58\u0005\f\u0000\u0000\u1c56\u1c58\u0001\u0000\u0000\u0000"+ + "\u1c57\u1c55\u0001\u0000\u0000\u0000\u1c57\u1c56\u0001\u0000\u0000\u0000"+ + "\u1c58\u032f\u0001\u0000\u0000\u0000\u1c59\u1c5a\u0005\u008c\u0000\u0000"+ + "\u1c5a\u1c5b\u0005\u00b1\u0000\u0000\u1c5b\u1c62\u0003\u053c\u029e\u0000"+ + "\u1c5c\u1c5d\u0005k\u0000\u0000\u1c5d\u1c63\u0003\u0326\u0193\u0000\u1c5e"+ + "\u1c63\u0003\u0326\u0193\u0000\u1c5f\u1c60\u0005\u0148\u0000\u0000\u1c60"+ + "\u1c61\u0005\u015a\u0000\u0000\u1c61\u1c63\u0003\u053c\u029e\u0000\u1c62"+ + "\u1c5c\u0001\u0000\u0000\u0000\u1c62\u1c5e\u0001\u0000\u0000\u0000\u1c62"+ + "\u1c5f\u0001\u0000\u0000\u0000\u1c63\u0331\u0001\u0000\u0000\u0000\u1c64"+ + "\u1c65\u0005\u008c\u0000\u0000\u1c65\u1c66\u0005\u00b1\u0000\u0000\u1c66"+ + "\u1c67\u0003\u053c\u029e\u0000\u1c67\u1c68\u0003P(\u0000\u1c68\u0333\u0001"+ + "\u0000\u0000\u0000\u1c69\u1c6a\u0005\u00c1\u0000\u0000\u1c6a\u1c6d\u0005"+ + "\u00b1\u0000\u0000\u1c6b\u1c6c\u0005\u00de\u0000\u0000\u1c6c\u1c6e\u0005"+ + "\u0187\u0000\u0000\u1c6d\u1c6b\u0001\u0000\u0000\u0000\u1c6d\u1c6e\u0001"+ + "\u0000\u0000\u0000\u1c6e\u1c6f\u0001\u0000\u0000\u0000\u1c6f\u1c75\u0003"+ + "\u053c\u029e\u0000\u1c70\u1c71\u0003\u0010\b\u0000\u1c71\u1c72\u0005\u0003"+ + "\u0000\u0000\u1c72\u1c73\u0003\u0336\u019b\u0000\u1c73\u1c74\u0005\u0004"+ + "\u0000\u0000\u1c74\u1c76\u0001\u0000\u0000\u0000\u1c75\u1c70\u0001\u0000"+ + "\u0000\u0000\u1c75\u1c76\u0001\u0000\u0000\u0000\u1c76\u0335\u0001\u0000"+ + "\u0000\u0000\u1c77\u1c7c\u0003\u0338\u019c\u0000\u1c78\u1c79\u0005\u0007"+ + "\u0000\u0000\u1c79\u1c7b\u0003\u0338\u019c\u0000\u1c7a\u1c78\u0001\u0000"+ + "\u0000\u0000\u1c7b\u1c7e\u0001\u0000\u0000\u0000\u1c7c\u1c7a\u0001\u0000"+ + "\u0000\u0000\u1c7c\u1c7d\u0001\u0000\u0000\u0000\u1c7d\u0337\u0001\u0000"+ + "\u0000\u0000\u1c7e\u1c7c\u0001\u0000\u0000\u0000\u1c7f\u1c80\u0005\u00d3"+ + "\u0000\u0000\u1c80\u0339\u0001\u0000\u0000\u0000\u1c81\u1c82\u0005\u008c"+ + "\u0000\u0000\u1c82\u1c83\u0005n\u0000\u0000\u1c83\u1c84\u0003\u020c\u0106"+ + "\u0000\u1c84\u1c85\u0005\u012c\u0000\u0000\u1c85\u1c86\u0005\u0172\u0000"+ + "\u0000\u1c86\u033b\u0001\u0000\u0000\u0000\u1c87\u1c88\u0005\u008c\u0000"+ + "\u0000\u1c88\u1c89\u0005\u0158\u0000\u0000\u1c89\u1c8a\u0007!\u0000\u0000"+ + "\u1c8a\u1c8b\u00036\u001b\u0000\u1c8b\u033d\u0001\u0000\u0000\u0000\u1c8c"+ + "\u1c8d\u00050\u0000\u0000\u1c8d\u1c8e\u0005\u00bf\u0000\u0000\u1c8e\u1c8f"+ + "\u0003\u020c\u0106\u0000\u1c8f\u1c90\u0003\u0342\u01a1\u0000\u1c90\u1c91"+ + "\u0003\u0460\u0230\u0000\u1c91\u1c92\u0003\u00c0`\u0000\u1c92\u033f\u0001"+ + "\u0000\u0000\u0000\u1c93\u1c94\u0005\u008c\u0000\u0000\u1c94\u1c95\u0005"+ + "\u00bf\u0000\u0000\u1c95\u1cab\u0003\u020c\u0106\u0000\u1c96\u1cac\u0003"+ + "j5\u0000\u1c97\u1c98\u0005\u00c1\u0000\u0000\u1c98\u1c99\u0005O\u0000"+ + "\u0000\u1c99\u1cac\u0005P\u0000\u0000\u1c9a\u1c9b\u0005\u0148\u0000\u0000"+ + "\u1c9b\u1c9c\u0005O\u0000\u0000\u1c9c\u1cac\u0005P\u0000\u0000\u1c9d\u1c9e"+ + "\u0005\u0087\u0000\u0000\u1c9e\u1cac\u0003\u00d0h\u0000\u1c9f\u1ca0\u0005"+ + "\u00c1\u0000\u0000\u1ca0\u1ca3\u0005/\u0000\u0000\u1ca1\u1ca2\u0005\u00de"+ + "\u0000\u0000\u1ca2\u1ca4\u0005\u0187\u0000\u0000\u1ca3\u1ca1\u0001\u0000"+ + "\u0000\u0000\u1ca3\u1ca4\u0001\u0000\u0000\u0000\u1ca4\u1ca5\u0001\u0000"+ + "\u0000\u0000\u1ca5\u1ca6\u0003\u053c\u029e\u0000\u1ca6\u1ca7\u0003l6\u0000"+ + "\u1ca7\u1cac\u0001\u0000\u0000\u0000\u1ca8\u1ca9\u0005\u016f\u0000\u0000"+ + "\u1ca9\u1caa\u0005/\u0000\u0000\u1caa\u1cac\u0003\u053c\u029e\u0000\u1cab"+ + "\u1c96\u0001\u0000\u0000\u0000\u1cab\u1c97\u0001\u0000\u0000\u0000\u1cab"+ + "\u1c9a\u0001\u0000\u0000\u0000\u1cab\u1c9d\u0001\u0000\u0000\u0000\u1cab"+ + "\u1c9f\u0001\u0000\u0000\u0000\u1cab\u1ca8\u0001\u0000\u0000\u0000\u1cac"+ + "\u0341\u0001\u0000\u0000\u0000\u1cad\u1cb0\u0005&\u0000\u0000\u1cae\u1cb0"+ + "\u0001\u0000\u0000\u0000\u1caf\u1cad\u0001\u0000\u0000\u0000\u1caf\u1cae"+ + "\u0001\u0000\u0000\u0000\u1cb0\u0343\u0001\u0000\u0000\u0000\u1cb1\u1cb2"+ + "\u0005\u008c\u0000\u0000\u1cb2\u1cb3\u0005\u015e\u0000\u0000\u1cb3\u1cb4"+ + "\u0005\u0140\u0000\u0000\u1cb4\u1cb5\u0005\u00bb\u0000\u0000\u1cb5\u1cb6"+ + "\u0003\u020c\u0106\u0000\u1cb6\u1cb7\u0003\u01cc\u00e6\u0000\u1cb7\u0345"+ + "\u0001\u0000\u0000\u0000\u1cb8\u1cb9\u0005\u008c\u0000\u0000\u1cb9\u1cba"+ + "\u0005\u015e\u0000\u0000\u1cba\u1cbb\u0005\u0140\u0000\u0000\u1cbb\u1cbc"+ + "\u0005\u00a5\u0000\u0000\u1cbc\u1cbd\u0003\u020c\u0106\u0000\u1cbd\u1cbe"+ + "\u0005\u0087\u0000\u0000\u1cbe\u1cbf\u0005\u00fa\u0000\u0000\u1cbf\u1cc0"+ + "\u0005@\u0000\u0000\u1cc0\u1cc1\u0003\u053a\u029d\u0000\u1cc1\u1cc2\u0003"+ + "\u0348\u01a4\u0000\u1cc2\u1cc3\u0003\u020a\u0105\u0000\u1cc3\u1d01\u0001"+ + "\u0000\u0000\u0000\u1cc4\u1cc5\u0005\u008c\u0000\u0000\u1cc5\u1cc6\u0005"+ + "\u015e\u0000\u0000\u1cc6\u1cc7\u0005\u0140\u0000\u0000\u1cc7\u1cc8\u0005"+ + "\u00a5\u0000\u0000\u1cc8\u1cc9\u0003\u020c\u0106\u0000\u1cc9\u1cca\u0005"+ + "\u008c\u0000\u0000\u1cca\u1ccb\u0005\u00fa\u0000\u0000\u1ccb\u1ccc\u0005"+ + "@\u0000\u0000\u1ccc\u1ccd\u0003\u053a\u029d\u0000\u1ccd\u1cce\u0003\u0348"+ + "\u01a4\u0000\u1cce\u1ccf\u0003\u020a\u0105\u0000\u1ccf\u1d01\u0001\u0000"+ + "\u0000\u0000\u1cd0\u1cd1\u0005\u008c\u0000\u0000\u1cd1\u1cd2\u0005\u015e"+ + "\u0000\u0000\u1cd2\u1cd3\u0005\u0140\u0000\u0000\u1cd3\u1cd4\u0005\u00a5"+ + "\u0000\u0000\u1cd4\u1cd5\u0003\u020c\u0106\u0000\u1cd5\u1cd6\u0005\u008c"+ + "\u0000\u0000\u1cd6\u1cd7\u0005\u00fa\u0000\u0000\u1cd7\u1cd8\u0005\u0132"+ + "\u0000\u0000\u1cd8\u1cd9\u0003\u020c\u0106\u0000\u1cd9\u1cda\u0003\u0348"+ + "\u01a4\u0000\u1cda\u1cdb\u0003\u020c\u0106\u0000\u1cdb\u1d01\u0001\u0000"+ + "\u0000\u0000\u1cdc\u1cdd\u0005\u008c\u0000\u0000\u1cdd\u1cde\u0005\u015e"+ + "\u0000\u0000\u1cde\u1cdf\u0005\u0140\u0000\u0000\u1cdf\u1ce0\u0005\u00a5"+ + "\u0000\u0000\u1ce0\u1ce1\u0003\u020c\u0106\u0000\u1ce1\u1ce2\u0005\u008c"+ + "\u0000\u0000\u1ce2\u1ce3\u0005\u00fa\u0000\u0000\u1ce3\u1ce4\u0005@\u0000"+ + "\u0000\u1ce4\u1ce5\u0003\u053a\u029d\u0000\u1ce5\u1ce6\u0005\u0132\u0000"+ + "\u0000\u1ce6\u1ce7\u0003\u020c\u0106\u0000\u1ce7\u1ce8\u0003\u0348\u01a4"+ + "\u0000\u1ce8\u1ce9\u0003\u020c\u0106\u0000\u1ce9\u1d01\u0001\u0000\u0000"+ + "\u0000\u1cea\u1ceb\u0005\u008c\u0000\u0000\u1ceb\u1cec\u0005\u015e\u0000"+ + "\u0000\u1cec\u1ced\u0005\u0140\u0000\u0000\u1ced\u1cee\u0005\u00a5\u0000"+ + "\u0000\u1cee\u1cef\u0003\u020c\u0106\u0000\u1cef\u1cf0\u0005\u00c1\u0000"+ + "\u0000\u1cf0\u1cf1\u0005\u00fa\u0000\u0000\u1cf1\u1cf2\u0005@\u0000\u0000"+ + "\u1cf2\u1cf3\u0003\u053a\u029d\u0000\u1cf3\u1d01\u0001\u0000\u0000\u0000"+ + "\u1cf4\u1cf5\u0005\u008c\u0000\u0000\u1cf5\u1cf6\u0005\u015e\u0000\u0000"+ + "\u1cf6\u1cf7\u0005\u0140\u0000\u0000\u1cf7\u1cf8\u0005\u00a5\u0000\u0000"+ + "\u1cf8\u1cf9\u0003\u020c\u0106\u0000\u1cf9\u1cfa\u0005\u00c1\u0000\u0000"+ + "\u1cfa\u1cfb\u0005\u00fa\u0000\u0000\u1cfb\u1cfc\u0005\u00de\u0000\u0000"+ + "\u1cfc\u1cfd\u0005\u0187\u0000\u0000\u1cfd\u1cfe\u0005@\u0000\u0000\u1cfe"+ + "\u1cff\u0003\u053a\u029d\u0000\u1cff\u1d01\u0001\u0000\u0000\u0000\u1d00"+ + "\u1cb8\u0001\u0000\u0000\u0000\u1d00\u1cc4\u0001\u0000\u0000\u0000\u1d00"+ + "\u1cd0\u0001\u0000\u0000\u0000\u1d00\u1cdc\u0001\u0000\u0000\u0000\u1d00"+ + "\u1cea\u0001\u0000\u0000\u0000\u1d00\u1cf4\u0001\u0000\u0000\u0000\u1d01"+ + "\u0347\u0001\u0000\u0000\u0000\u1d02\u1d03\u0005k\u0000\u0000\u1d03\u0349"+ + "\u0001\u0000\u0000\u0000\u1d04\u1d05\u00050\u0000\u0000\u1d05\u1d06\u0003"+ + "\u01e8\u00f4\u0000\u1d06\u1d07\u0005\u00aa\u0000\u0000\u1d07\u1d08\u0003"+ + "\u020c\u0106\u0000\u1d08\u1d09\u0005@\u0000\u0000\u1d09\u1d0a\u0003\u054e"+ + "\u02a7\u0000\u1d0a\u1d0b\u0005`\u0000\u0000\u1d0b\u1d0c\u0003\u054e\u02a7"+ + "\u0000\u1d0c\u1d0d\u0005B\u0000\u0000\u1d0d\u1d0e\u0003\u020c\u0106\u0000"+ + "\u1d0e\u034b\u0001\u0000\u0000\u0000\u1d0f\u1d10\u0005\u00a0\u0000\u0000"+ + "\u1d10\u1d11\u0003\u0360\u01b0\u0000\u1d11\u1d12\u0003\u0538\u029c\u0000"+ + "\u1d12\u1d13\u0003\u034e\u01a7\u0000\u1d13\u1d1d\u0001\u0000\u0000\u0000"+ + "\u1d14\u1d15\u0005\u00a0\u0000\u0000\u1d15\u1d1d\u0003\u0360\u01b0\u0000"+ + "\u1d16\u1d17\u0005\u00a0\u0000\u0000\u1d17\u1d18\u0003\u0360\u01b0\u0000"+ + "\u1d18\u1d19\u0003\u053c\u029e\u0000\u1d19\u1d1a\u0005R\u0000\u0000\u1d1a"+ + "\u1d1b\u0003\u0538\u029c\u0000\u1d1b\u1d1d\u0001\u0000\u0000\u0000\u1d1c"+ + "\u1d0f\u0001\u0000\u0000\u0000\u1d1c\u1d14\u0001\u0000\u0000\u0000\u1d1c"+ + "\u1d16\u0001\u0000\u0000\u0000\u1d1d\u034d\u0001\u0000\u0000\u0000\u1d1e"+ + "\u1d1f\u0005f\u0000\u0000\u1d1f\u1d22\u0003\u053c\u029e\u0000\u1d20\u1d22"+ + "\u0001\u0000\u0000\u0000\u1d21\u1d1e\u0001\u0000\u0000\u0000\u1d21\u1d20"+ + "\u0001\u0000\u0000\u0000\u1d22\u034f\u0001\u0000\u0000\u0000\u1d23\u1d24"+ + "\u0005\u016d\u0000\u0000\u1d24\u1d25\u0003\u0362\u01b1\u0000\u1d25\u1d26"+ + "\u0003\u0364\u01b2\u0000\u1d26\u1d27\u0003\u0360\u01b0\u0000\u1d27\u1d28"+ + "\u0003\u035e\u01af\u0000\u1d28\u1d29\u0003\u036c\u01b6\u0000\u1d29\u1d31"+ + "\u0001\u0000\u0000\u0000\u1d2a\u1d2b\u0005\u016d\u0000\u0000\u1d2b\u1d2c"+ + "\u0005\u0003\u0000\u0000\u1d2c\u1d2d\u0003\u0354\u01aa\u0000\u1d2d\u1d2e"+ + "\u0005\u0004\u0000\u0000\u1d2e\u1d2f\u0003\u036c\u01b6\u0000\u1d2f\u1d31"+ + "\u0001\u0000\u0000\u0000\u1d30\u1d23\u0001\u0000\u0000\u0000\u1d30\u1d2a"+ + "\u0001\u0000\u0000\u0000\u1d31\u0351\u0001\u0000\u0000\u0000\u1d32\u1d33"+ + "\u0003\u0356\u01ab\u0000\u1d33\u1d34\u0003\u0360\u01b0\u0000\u1d34\u1d35"+ + "\u0003\u036c\u01b6\u0000\u1d35\u1d3d\u0001\u0000\u0000\u0000\u1d36\u1d37"+ + "\u0003\u0356\u01ab\u0000\u1d37\u1d38\u0005\u0003\u0000\u0000\u1d38\u1d39"+ + "\u0003\u0354\u01aa\u0000\u1d39\u1d3a\u0005\u0004\u0000\u0000\u1d3a\u1d3b"+ + "\u0003\u036c\u01b6\u0000\u1d3b\u1d3d\u0001\u0000\u0000\u0000\u1d3c\u1d32"+ + "\u0001\u0000\u0000\u0000\u1d3c\u1d36\u0001\u0000\u0000\u0000\u1d3d\u0353"+ + "\u0001\u0000\u0000\u0000\u1d3e\u1d43\u0003\u0358\u01ac\u0000\u1d3f\u1d40"+ + "\u0005\u0007\u0000\u0000\u1d40\u1d42\u0003\u0358\u01ac\u0000\u1d41\u1d3f"+ + "\u0001\u0000\u0000\u0000\u1d42\u1d45\u0001\u0000\u0000\u0000\u1d43\u1d41"+ + "\u0001\u0000\u0000\u0000\u1d43\u1d44\u0001\u0000\u0000\u0000\u1d44\u0355"+ + "\u0001\u0000\u0000\u0000\u1d45\u1d43\u0001\u0000\u0000\u0000\u1d46\u1d47"+ + "\u0007\"\u0000\u0000\u1d47\u0357\u0001\u0000\u0000\u0000\u1d48\u1d49\u0003"+ + "\u035a\u01ad\u0000\u1d49\u1d4a\u0003\u035c\u01ae\u0000\u1d4a\u0359\u0001"+ + "\u0000\u0000\u0000\u1d4b\u1d4e\u0003\u0562\u02b1\u0000\u1d4c\u1d4e\u0003"+ + "\u0356\u01ab\u0000\u1d4d\u1d4b\u0001\u0000\u0000\u0000\u1d4d\u1d4c\u0001"+ + "\u0000\u0000\u0000\u1d4e\u035b\u0001\u0000\u0000\u0000\u1d4f\u1d53\u0003"+ + "B!\u0000\u1d50\u1d53\u0003\u0124\u0092\u0000\u1d51\u1d53\u0001\u0000\u0000"+ + "\u0000\u1d52\u1d4f\u0001\u0000\u0000\u0000\u1d52\u1d50\u0001\u0000\u0000"+ + "\u0000\u1d52\u1d51\u0001\u0000\u0000\u0000\u1d53\u035d\u0001\u0000\u0000"+ + "\u0000\u1d54\u1d57\u0003\u0356\u01ab\u0000\u1d55\u1d57\u0001\u0000\u0000"+ + "\u0000\u1d56\u1d54\u0001\u0000\u0000\u0000\u1d56\u1d55\u0001\u0000\u0000"+ + "\u0000\u1d57\u035f\u0001\u0000\u0000\u0000\u1d58\u1d5b\u0005\u0082\u0000"+ + "\u0000\u1d59\u1d5b\u0001\u0000\u0000\u0000\u1d5a\u1d58\u0001\u0000\u0000"+ + "\u0000\u1d5a\u1d59\u0001\u0000\u0000\u0000\u1d5b\u0361\u0001\u0000\u0000"+ + "\u0000\u1d5c\u1d5f\u0005s\u0000\u0000\u1d5d\u1d5f\u0001\u0000\u0000\u0000"+ + "\u1d5e\u1d5c\u0001\u0000\u0000\u0000\u1d5e\u1d5d\u0001\u0000\u0000\u0000"+ + "\u1d5f\u0363\u0001\u0000\u0000\u0000\u1d60\u1d63\u0005r\u0000\u0000\u1d61"+ + "\u1d63\u0001\u0000\u0000\u0000\u1d62\u1d60\u0001\u0000\u0000\u0000\u1d62"+ + "\u1d61\u0001\u0000\u0000\u0000\u1d63\u0365\u0001\u0000\u0000\u0000\u1d64"+ + "\u1d65\u0005\u0003\u0000\u0000\u1d65\u1d66\u0003\u053a\u029d\u0000\u1d66"+ + "\u1d67\u0005\u0004\u0000\u0000\u1d67\u1d6a\u0001\u0000\u0000\u0000\u1d68"+ + "\u1d6a\u0001\u0000\u0000\u0000\u1d69\u1d64\u0001\u0000\u0000\u0000\u1d69"+ + "\u1d68\u0001\u0000\u0000\u0000\u1d6a\u0367\u0001\u0000\u0000\u0000\u1d6b"+ + "\u1d6c\u0003\u0538\u029c\u0000\u1d6c\u1d6d\u0003\u0366\u01b3\u0000\u1d6d"+ + "\u0369\u0001\u0000\u0000\u0000\u1d6e\u1d73\u0003\u0368\u01b4\u0000\u1d6f"+ + "\u1d70\u0005\u0007\u0000\u0000\u1d70\u1d72\u0003\u0368\u01b4\u0000\u1d71"+ + "\u1d6f\u0001\u0000\u0000\u0000\u1d72\u1d75\u0001\u0000\u0000\u0000\u1d73"+ + "\u1d71\u0001\u0000\u0000\u0000\u1d73\u1d74\u0001\u0000\u0000\u0000\u1d74"+ + "\u036b\u0001\u0000\u0000\u0000\u1d75\u1d73\u0001\u0000\u0000\u0000\u1d76"+ + "\u1d79\u0003\u036a\u01b5\u0000\u1d77\u1d79\u0001\u0000\u0000\u0000\u1d78"+ + "\u1d76\u0001\u0000\u0000\u0000\u1d78\u1d77\u0001\u0000\u0000\u0000\u1d79"+ + "\u036d\u0001\u0000\u0000\u0000\u1d7a\u1d7b\u0005\u00cd\u0000\u0000\u1d7b"+ + "\u1d8b\u0003\u0370\u01b8\u0000\u1d7c\u1d7d\u0005\u00cd\u0000\u0000\u1d7d"+ + "\u1d7e\u0003\u0356\u01ab\u0000\u1d7e\u1d7f\u0003\u0360\u01b0\u0000\u1d7f"+ + "\u1d80\u0003\u0370\u01b8\u0000\u1d80\u1d8b\u0001\u0000\u0000\u0000\u1d81"+ + "\u1d82\u0005\u00cd\u0000\u0000\u1d82\u1d83\u0005\u0082\u0000\u0000\u1d83"+ + "\u1d8b\u0003\u0370\u01b8\u0000\u1d84\u1d85\u0005\u00cd\u0000\u0000\u1d85"+ + "\u1d86\u0005\u0003\u0000\u0000\u1d86\u1d87\u0003\u0372\u01b9\u0000\u1d87"+ + "\u1d88\u0005\u0004\u0000\u0000\u1d88\u1d89\u0003\u0370\u01b8\u0000\u1d89"+ + "\u1d8b\u0001\u0000\u0000\u0000\u1d8a\u1d7a\u0001\u0000\u0000\u0000\u1d8a"+ + "\u1d7c\u0001\u0000\u0000\u0000\u1d8a\u1d81\u0001\u0000\u0000\u0000\u1d8a"+ + "\u1d84\u0001\u0000\u0000\u0000\u1d8b\u036f\u0001\u0000\u0000\u0000\u1d8c"+ + "\u1d96\u0003\u03c0\u01e0\u0000\u1d8d\u1d96\u0003\u0386\u01c3\u0000\u1d8e"+ + "\u1d96\u0003\u03ae\u01d7\u0000\u1d8f\u1d96\u0003\u03a0\u01d0\u0000\u1d90"+ + "\u1d96\u0003\u03b8\u01dc\u0000\u1d91\u1d96\u0003\u0108\u0084\u0000\u1d92"+ + "\u1d96\u0003\u010e\u0087\u0000\u1d93\u1d96\u0003\u0114\u008a\u0000\u1d94"+ + "\u1d96\u0003\u0380\u01c0\u0000\u1d95\u1d8c\u0001\u0000\u0000\u0000\u1d95"+ + "\u1d8d\u0001\u0000\u0000\u0000\u1d95\u1d8e\u0001\u0000\u0000\u0000\u1d95"+ + "\u1d8f\u0001\u0000\u0000\u0000\u1d95\u1d90\u0001\u0000\u0000\u0000\u1d95"+ + "\u1d91\u0001\u0000\u0000\u0000\u1d95\u1d92\u0001\u0000\u0000\u0000\u1d95"+ + "\u1d93\u0001\u0000\u0000\u0000\u1d95\u1d94\u0001\u0000\u0000\u0000\u1d96"+ + "\u0371\u0001\u0000\u0000\u0000\u1d97\u1d9c\u0003\u0374\u01ba\u0000\u1d98"+ + "\u1d99\u0005\u0007\u0000\u0000\u1d99\u1d9b\u0003\u0374\u01ba\u0000\u1d9a"+ + "\u1d98\u0001\u0000\u0000\u0000\u1d9b\u1d9e\u0001\u0000\u0000\u0000\u1d9c"+ + "\u1d9a\u0001\u0000\u0000\u0000\u1d9c\u1d9d\u0001\u0000\u0000\u0000\u1d9d"+ + "\u0373\u0001\u0000\u0000\u0000\u1d9e\u1d9c\u0001\u0000\u0000\u0000\u1d9f"+ + "\u1da0\u0003\u0376\u01bb\u0000\u1da0\u1da1\u0003\u0378\u01bc\u0000\u1da1"+ + "\u0375\u0001\u0000\u0000\u0000\u1da2\u1da5\u0003\u0562\u02b1\u0000\u1da3"+ + "\u1da5\u0003\u0356\u01ab\u0000\u1da4\u1da2\u0001\u0000\u0000\u0000\u1da4"+ + "\u1da3\u0001\u0000\u0000\u0000\u1da5\u0377\u0001\u0000\u0000\u0000\u1da6"+ + "\u1daa\u0003B!\u0000\u1da7\u1daa\u0003\u0124\u0092\u0000\u1da8\u1daa\u0001"+ + "\u0000\u0000\u0000\u1da9\u1da6\u0001\u0000\u0000\u0000\u1da9\u1da7\u0001"+ + "\u0000\u0000\u0000\u1da9\u1da8\u0001\u0000\u0000\u0000\u1daa\u0379\u0001"+ + "\u0000\u0000\u0000\u1dab\u1dac\u0005\u011d\u0000\u0000\u1dac\u1dad\u0003"+ + "\u053c\u029e\u0000\u1dad\u1dae\u0003\u037c\u01be\u0000\u1dae\u1daf\u0005"+ + "&\u0000\u0000\u1daf\u1db0\u0003\u037e\u01bf\u0000\u1db0\u037b\u0001\u0000"+ + "\u0000\u0000\u1db1\u1db2\u0005\u0003\u0000\u0000\u1db2\u1db3\u0003\u0506"+ + "\u0283\u0000\u1db3\u1db4\u0005\u0004\u0000\u0000\u1db4\u1db7\u0001\u0000"+ + "\u0000\u0000\u1db5\u1db7\u0001\u0000\u0000\u0000\u1db6\u1db1\u0001\u0000"+ + "\u0000\u0000\u1db6\u1db5\u0001\u0000\u0000\u0000\u1db7\u037d\u0001\u0000"+ + "\u0000\u0000\u1db8\u1dbd\u0003\u03c0\u01e0\u0000\u1db9\u1dbd\u0003\u0386"+ + "\u01c3\u0000\u1dba\u1dbd\u0003\u03ae\u01d7\u0000\u1dbb\u1dbd\u0003\u03a0"+ + "\u01d0\u0000\u1dbc\u1db8\u0001\u0000\u0000\u0000\u1dbc\u1db9\u0001\u0000"+ + "\u0000\u0000\u1dbc\u1dba\u0001\u0000\u0000\u0000\u1dbc\u1dbb\u0001\u0000"+ + "\u0000\u0000\u1dbd\u037f\u0001\u0000\u0000\u0000\u1dbe\u1dbf\u0005\u00cc"+ + "\u0000\u0000\u1dbf\u1dc0\u0003\u053c\u029e\u0000\u1dc0\u1dc1\u0003\u0382"+ + "\u01c1\u0000\u1dc1\u1dda\u0001\u0000\u0000\u0000\u1dc2\u1dc3\u00050\u0000"+ + "\u0000\u1dc3\u1dc4\u0003\u00aeW\u0000\u1dc4\u1dc5\u0005^\u0000\u0000\u1dc5"+ + "\u1dc6\u0003\u010a\u0085\u0000\u1dc6\u1dc7\u0005&\u0000\u0000\u1dc7\u1dc8"+ + "\u0005\u00cc\u0000\u0000\u1dc8\u1dc9\u0003\u053c\u029e\u0000\u1dc9\u1dca"+ + "\u0003\u0382\u01c1\u0000\u1dca\u1dcb\u0003\u010c\u0086\u0000\u1dcb\u1dda"+ + "\u0001\u0000\u0000\u0000\u1dcc\u1dcd\u00050\u0000\u0000\u1dcd\u1dce\u0003"+ + "\u00aeW\u0000\u1dce\u1dcf\u0005^\u0000\u0000\u1dcf\u1dd0\u0005\u00de\u0000"+ + "\u0000\u1dd0\u1dd1\u0005O\u0000\u0000\u1dd1\u1dd2\u0005\u0187\u0000\u0000"+ + "\u1dd2\u1dd3\u0003\u010a\u0085\u0000\u1dd3\u1dd4\u0005&\u0000\u0000\u1dd4"+ + "\u1dd5\u0005\u00cc\u0000\u0000\u1dd5\u1dd6\u0003\u053c\u029e\u0000\u1dd6"+ + "\u1dd7\u0003\u0382\u01c1\u0000\u1dd7\u1dd8\u0003\u010c\u0086\u0000\u1dd8"+ + "\u1dda\u0001\u0000\u0000\u0000\u1dd9\u1dbe\u0001\u0000\u0000\u0000\u1dd9"+ + "\u1dc2\u0001\u0000\u0000\u0000\u1dd9\u1dcc\u0001\u0000\u0000\u0000\u1dda"+ + "\u0381\u0001\u0000\u0000\u0000\u1ddb\u1ddc\u0005\u0003\u0000\u0000\u1ddc"+ + "\u1ddd\u0003\u0500\u0280\u0000\u1ddd\u1dde\u0005\u0004\u0000\u0000\u1dde"+ + "\u1de1\u0001\u0000\u0000\u0000\u1ddf\u1de1\u0001\u0000\u0000\u0000\u1de0"+ + "\u1ddb\u0001\u0000\u0000\u0000\u1de0\u1ddf\u0001\u0000\u0000\u0000\u1de1"+ + "\u0383\u0001\u0000\u0000\u0000\u1de2\u1de3\u0005\u00b3\u0000\u0000\u1de3"+ + "\u1ded\u0003\u053c\u029e\u0000\u1de4\u1de5\u0005\u00b3\u0000\u0000\u1de5"+ + "\u1de6\u0005\u011d\u0000\u0000\u1de6\u1ded\u0003\u053c\u029e\u0000\u1de7"+ + "\u1de8\u0005\u00b3\u0000\u0000\u1de8\u1ded\u0005 \u0000\u0000\u1de9\u1dea"+ + "\u0005\u00b3\u0000\u0000\u1dea\u1deb\u0005\u011d\u0000\u0000\u1deb\u1ded"+ + "\u0005 \u0000\u0000\u1dec\u1de2\u0001\u0000\u0000\u0000\u1dec\u1de4\u0001"+ + "\u0000\u0000\u0000\u1dec\u1de7\u0001\u0000\u0000\u0000\u1dec\u1de9\u0001"+ + "\u0000\u0000\u0000\u1ded\u0385\u0001\u0000\u0000\u0000\u1dee\u1def\u0003"+ + "\u03d6\u01eb\u0000\u1def\u1df0\u0005\u00ea\u0000\u0000\u1df0\u1df1\u0005"+ + "I\u0000\u0000\u1df1\u1df2\u0003\u0388\u01c4\u0000\u1df2\u1df3\u0003\u038a"+ + "\u01c5\u0000\u1df3\u1df4\u0003\u0392\u01c9\u0000\u1df4\u1df5\u0003\u0396"+ + "\u01cb\u0000\u1df5\u0387\u0001\u0000\u0000\u0000\u1df6\u1df9\u0003\u0538"+ + "\u029c\u0000\u1df7\u1df8\u0005&\u0000\u0000\u1df8\u1dfa\u0003\u055c\u02ae"+ + "\u0000\u1df9\u1df7\u0001\u0000\u0000\u0000\u1df9\u1dfa\u0001\u0000\u0000"+ + "\u0000\u1dfa\u0389\u0001\u0000\u0000\u0000\u1dfb\u1e0f\u0003\u03c0\u01e0"+ + "\u0000\u1dfc\u1dfd\u0005\u01d1\u0000\u0000\u1dfd\u1dfe\u0003\u038c\u01c6"+ + "\u0000\u1dfe\u1dff\u0005\u01c4\u0000\u0000\u1dff\u1e00\u0003\u03c0\u01e0"+ + "\u0000\u1e00\u1e0f\u0001\u0000\u0000\u0000\u1e01\u1e02\u0005\u0003\u0000"+ + "\u0000\u1e02\u1e03\u0003\u038e\u01c7\u0000\u1e03\u1e08\u0005\u0004\u0000"+ + "\u0000\u1e04\u1e05\u0005\u01d1\u0000\u0000\u1e05\u1e06\u0003\u038c\u01c6"+ + "\u0000\u1e06\u1e07\u0005\u01c4\u0000\u0000\u1e07\u1e09\u0001\u0000\u0000"+ + "\u0000\u1e08\u1e04\u0001\u0000\u0000\u0000\u1e08\u1e09\u0001\u0000\u0000"+ + "\u0000\u1e09\u1e0a\u0001\u0000\u0000\u0000\u1e0a\u1e0b\u0003\u03c0\u01e0"+ + "\u0000\u1e0b\u1e0f\u0001\u0000\u0000\u0000\u1e0c\u1e0d\u00057\u0000\u0000"+ + "\u1e0d\u1e0f\u0005\u01a1\u0000\u0000\u1e0e\u1dfb\u0001\u0000\u0000\u0000"+ + "\u1e0e\u1dfc\u0001\u0000\u0000\u0000\u1e0e\u1e01\u0001\u0000\u0000\u0000"+ + "\u1e0e\u1e0c\u0001\u0000\u0000\u0000\u1e0f\u038b\u0001\u0000\u0000\u0000"+ + "\u1e10\u1e11\u0007#\u0000\u0000\u1e11\u038d\u0001\u0000\u0000\u0000\u1e12"+ + "\u1e17\u0003\u0390\u01c8\u0000\u1e13\u1e14\u0005\u0007\u0000\u0000\u1e14"+ + "\u1e16\u0003\u0390\u01c8\u0000\u1e15\u1e13\u0001\u0000\u0000\u0000\u1e16"+ + "\u1e19\u0001\u0000\u0000\u0000\u1e17\u1e15\u0001\u0000\u0000\u0000\u1e17"+ + "\u1e18\u0001\u0000\u0000\u0000\u1e18\u038f\u0001\u0000\u0000\u0000\u1e19"+ + "\u1e17\u0001\u0000\u0000\u0000\u1e1a\u1e1b\u0003\u055c\u02ae\u0000\u1e1b"+ + "\u1e1c\u0003\u052e\u0297\u0000\u1e1c\u0391\u0001\u0000\u0000\u0000\u1e1d"+ + "\u1e1e\u0005R\u0000\u0000\u1e1e\u1e1f\u0005\u01d2\u0000\u0000\u1e1f\u1e20"+ + "\u0003\u0394\u01ca\u0000\u1e20\u1e27\u0005;\u0000\u0000\u1e21\u1e22\u0005"+ + "\u016c\u0000\u0000\u1e22\u1e23\u0005\u0148\u0000\u0000\u1e23\u1e24\u0003"+ + "\u03b0\u01d8\u0000\u1e24\u1e25\u0003\u0448\u0224\u0000\u1e25\u1e28\u0001"+ + "\u0000\u0000\u0000\u1e26\u1e28\u0005\u0109\u0000\u0000\u1e27\u1e21\u0001"+ + "\u0000\u0000\u0000\u1e27\u1e26\u0001\u0000\u0000\u0000\u1e28\u1e2b\u0001"+ + "\u0000\u0000\u0000\u1e29\u1e2b\u0001\u0000\u0000\u0000\u1e2a\u1e1d\u0001"+ + "\u0000\u0000\u0000\u1e2a\u1e29\u0001\u0000\u0000\u0000\u1e2b\u0393\u0001"+ + "\u0000\u0000\u0000\u1e2c\u1e2d\u0005\u0003\u0000\u0000\u1e2d\u1e2e\u0003"+ + "\u0256\u012b\u0000\u1e2e\u1e2f\u0005\u0004\u0000\u0000\u1e2f\u1e30\u0003"+ + "\u0448\u0224\u0000\u1e30\u1e36\u0001\u0000\u0000\u0000\u1e31\u1e32\u0005"+ + "R\u0000\u0000\u1e32\u1e33\u0005/\u0000\u0000\u1e33\u1e36\u0003\u053c\u029e"+ + "\u0000\u1e34\u1e36\u0001\u0000\u0000\u0000\u1e35\u1e2c\u0001\u0000\u0000"+ + "\u0000\u1e35\u1e31\u0001\u0000\u0000\u0000\u1e35\u1e34\u0001\u0000\u0000"+ + "\u0000\u1e36\u0395\u0001\u0000\u0000\u0000\u1e37\u1e38\u0005Y\u0000\u0000"+ + "\u1e38\u1e3b\u0003\u0532\u0299\u0000\u1e39\u1e3b\u0001\u0000\u0000\u0000"+ + "\u1e3a\u1e37\u0001\u0000\u0000\u0000\u1e3a\u1e39\u0001\u0000\u0000\u0000"+ + "\u1e3b\u0397\u0001\u0000\u0000\u0000\u1e3c\u1e3e\u0005\u00ff\u0000\u0000"+ + "\u1e3d\u1e3f\u0005I\u0000\u0000\u1e3e\u1e3d\u0001\u0000\u0000\u0000\u1e3e"+ + "\u1e3f\u0001\u0000\u0000\u0000\u1e3f\u1e40\u0001\u0000\u0000\u0000\u1e40"+ + "\u1e42\u0003\u0538\u029c\u0000\u1e41\u1e43\u0003\u0428\u0214\u0000\u1e42"+ + "\u1e41\u0001\u0000\u0000\u0000\u1e42\u1e43\u0001\u0000\u0000\u0000\u1e43"+ + "\u1e44\u0001\u0000\u0000\u0000\u1e44\u1e47\u0005f\u0000\u0000\u1e45\u1e48"+ + "\u0003\u03c2\u01e1\u0000\u1e46\u1e48\u0003\u0538\u029c\u0000\u1e47\u1e45"+ + "\u0001\u0000\u0000\u0000\u1e47\u1e46\u0001\u0000\u0000\u0000\u1e48\u1e4a"+ + "\u0001\u0000\u0000\u0000\u1e49\u1e4b\u0003\u0428\u0214\u0000\u1e4a\u1e49"+ + "\u0001\u0000\u0000\u0000\u1e4a\u1e4b\u0001\u0000\u0000\u0000\u1e4b\u1e4c"+ + "\u0001\u0000\u0000\u0000\u1e4c\u1e4d\u0005R\u0000\u0000\u1e4d\u1e56\u0003"+ + "\u048c\u0246\u0000\u1e4e\u1e50\u0003\u039a\u01cd\u0000\u1e4f\u1e51\u0003"+ + "\u039c\u01ce\u0000\u1e50\u1e4f\u0001\u0000\u0000\u0000\u1e50\u1e51\u0001"+ + "\u0000\u0000\u0000\u1e51\u1e57\u0001\u0000\u0000\u0000\u1e52\u1e54\u0003"+ + "\u039c\u01ce\u0000\u1e53\u1e55\u0003\u039a\u01cd\u0000\u1e54\u1e53\u0001"+ + "\u0000\u0000\u0000\u1e54\u1e55\u0001\u0000\u0000\u0000\u1e55\u1e57\u0001"+ + "\u0000\u0000\u0000\u1e56\u1e4e\u0001\u0000\u0000\u0000\u1e56\u1e52\u0001"+ + "\u0000\u0000\u0000\u1e57\u1e59\u0001\u0000\u0000\u0000\u1e58\u1e5a\u0003"+ + "\u039e\u01cf\u0000\u1e59\u1e58\u0001\u0000\u0000\u0000\u1e59\u1e5a\u0001"+ + "\u0000\u0000\u0000\u1e5a\u0399\u0001\u0000\u0000\u0000\u1e5b\u1e5c\u0005"+ + "h\u0000\u0000\u1e5c\u1e5d\u0005O\u0000\u0000\u1e5d\u1e60\u0005\u00fc\u0000"+ + "\u0000\u1e5e\u1e5f\u0005#\u0000\u0000\u1e5f\u1e61\u0003\u048c\u0246\u0000"+ + "\u1e60\u1e5e\u0001\u0000\u0000\u0000\u1e60\u1e61\u0001\u0000\u0000\u0000"+ + "\u1e61\u1e63\u0001\u0000\u0000\u0000\u1e62\u1e64\u0005_\u0000\u0000\u1e63"+ + "\u1e62\u0001\u0000\u0000\u0000\u1e63\u1e64\u0001\u0000\u0000\u0000\u1e64"+ + "\u1e65\u0001\u0000\u0000\u0000\u1e65\u1e6a\u0005\u00ea\u0000\u0000\u1e66"+ + "\u1e67\u0005\u0003\u0000\u0000\u1e67\u1e68\u0003\u038e\u01c7\u0000\u1e68"+ + "\u1e69\u0005\u0004\u0000\u0000\u1e69\u1e6b\u0001\u0000\u0000\u0000\u1e6a"+ + "\u1e66\u0001\u0000\u0000\u0000\u1e6a\u1e6b\u0001\u0000\u0000\u0000\u1e6b"+ + "\u1e6c\u0001\u0000\u0000\u0000\u1e6c\u1e6d\u0003\u041e\u020f\u0000\u1e6d"+ + "\u039b\u0001\u0000\u0000\u0000\u1e6e\u1e6f\u0005h\u0000\u0000\u1e6f\u1e72"+ + "\u0005\u00fc\u0000\u0000\u1e70\u1e71\u0005#\u0000\u0000\u1e71\u1e73\u0003"+ + "\u048c\u0246\u0000\u1e72\u1e70\u0001\u0000\u0000\u0000\u1e72\u1e73\u0001"+ + "\u0000\u0000\u0000\u1e73\u1e75\u0001\u0000\u0000\u0000\u1e74\u1e76\u0005"+ + "_\u0000\u0000\u1e75\u1e74\u0001\u0000\u0000\u0000\u1e75\u1e76\u0001\u0000"+ + "\u0000\u0000\u1e76\u1e77\u0001\u0000\u0000\u0000\u1e77\u1e78\u0005\u016c"+ + "\u0000\u0000\u1e78\u1e79\u0005\u0148\u0000\u0000\u1e79\u1e7a\u0003\u03b0"+ + "\u01d8\u0000\u1e7a\u039d\u0001\u0000\u0000\u0000\u1e7b\u1e7c\u0005h\u0000"+ + "\u0000\u1e7c\u1e7e\u0005\u00fc\u0000\u0000\u1e7d\u1e7f\u0005_\u0000\u0000"+ + "\u1e7e\u1e7d\u0001\u0000\u0000\u0000\u1e7e\u1e7f\u0001\u0000\u0000\u0000"+ + "\u1e7f\u1e80\u0001\u0000\u0000\u0000\u1e80\u1e81\u0005\u00b8\u0000\u0000"+ + "\u1e81\u039f\u0001\u0000\u0000\u0000\u1e82\u1e83\u0003\u03d6\u01eb\u0000"+ + "\u1e83\u1e84\u0005\u00b8\u0000\u0000\u1e84\u1e85\u0005B\u0000\u0000\u1e85"+ + "\u1e86\u0003\u0438\u021c\u0000\u1e86\u1e87\u0003\u03a2\u01d1\u0000\u1e87"+ + "\u1e88\u0003\u044a\u0225\u0000\u1e88\u1e89\u0003\u0396\u01cb\u0000\u1e89"+ + "\u03a1\u0001\u0000\u0000\u0000\u1e8a\u1e8b\u0005f\u0000\u0000\u1e8b\u1e8e"+ + "\u0003\u0422\u0211\u0000\u1e8c\u1e8e\u0001\u0000\u0000\u0000\u1e8d\u1e8a"+ + "\u0001\u0000\u0000\u0000\u1e8d\u1e8c\u0001\u0000\u0000\u0000\u1e8e\u03a3"+ + "\u0001\u0000\u0000\u0000\u1e8f\u1e90\u0005\u00f9\u0000\u0000\u1e90\u1e91"+ + "\u0003\u03de\u01ef\u0000\u1e91\u1e92\u0003\u0436\u021b\u0000\u1e92\u1e93"+ + "\u0003\u03a6\u01d3\u0000\u1e93\u1e94\u0003\u03aa\u01d5\u0000\u1e94\u03a5"+ + "\u0001\u0000\u0000\u0000\u1e95\u1e96\u0005F\u0000\u0000\u1e96\u1e97\u0003"+ + "\u03a8\u01d4\u0000\u1e97\u1e98\u0005\u0102\u0000\u0000\u1e98\u1e9b\u0001"+ + "\u0000\u0000\u0000\u1e99\u1e9b\u0001\u0000\u0000\u0000\u1e9a\u1e95\u0001"+ + "\u0000\u0000\u0000\u1e9a\u1e99\u0001\u0000\u0000\u0000\u1e9b\u03a7\u0001"+ + "\u0000\u0000\u0000\u1e9c\u1e9d\u0005\u0085\u0000\u0000\u1e9d\u1ea9\u0007"+ + "$\u0000\u0000\u1e9e\u1e9f\u0005\u0199\u0000\u0000\u1e9f\u1ea9\u0007$\u0000"+ + "\u0000\u1ea0\u1ea5\u0005\u0149\u0000\u0000\u1ea1\u1ea2\u0005\u016c\u0000"+ + "\u0000\u1ea2\u1ea6\u0005\u00cb\u0000\u0000\u1ea3\u1ea4\u0005\u0199\u0000"+ + "\u0000\u1ea4\u1ea6\u0005\u00cb\u0000\u0000\u1ea5\u1ea1\u0001\u0000\u0000"+ + "\u0000\u1ea5\u1ea3\u0001\u0000\u0000\u0000\u1ea5\u1ea6\u0001\u0000\u0000"+ + "\u0000\u1ea6\u1ea9\u0001\u0000\u0000\u0000\u1ea7\u1ea9\u0005\u00cb\u0000"+ + "\u0000\u1ea8\u1e9c\u0001\u0000\u0000\u0000\u1ea8\u1e9e\u0001\u0000\u0000"+ + "\u0000\u1ea8\u1ea0\u0001\u0000\u0000\u0000\u1ea8\u1ea7\u0001\u0000\u0000"+ + "\u0000\u1ea9\u03a9\u0001\u0000\u0000\u0000\u1eaa\u1ead\u0005\u010b\u0000"+ + "\u0000\u1eab\u1ead\u0001\u0000\u0000\u0000\u1eac\u1eaa\u0001\u0000\u0000"+ + "\u0000\u1eac\u1eab\u0001\u0000\u0000\u0000\u1ead\u03ab\u0001\u0000\u0000"+ + "\u0000\u1eae\u1eb3\u0005\u010b\u0000\u0000\u1eaf\u1eb0\u0005\u01d3\u0000"+ + "\u0000\u1eb0\u1eb3\u0005\u01d4\u0000\u0000\u1eb1\u1eb3\u0001\u0000\u0000"+ + "\u0000\u1eb2\u1eae\u0001\u0000\u0000\u0000\u1eb2\u1eaf\u0001\u0000\u0000"+ + "\u0000\u1eb2\u1eb1\u0001\u0000\u0000\u0000\u1eb3\u03ad\u0001\u0000\u0000"+ + "\u0000\u1eb4\u1eb5\u0003\u03d6\u01eb\u0000\u1eb5\u1eb6\u0005\u016c\u0000"+ + "\u0000\u1eb6\u1eb7\u0003\u0438\u021c\u0000\u1eb7\u1eb8\u0005\u0148\u0000"+ + "\u0000\u1eb8\u1eb9\u0003\u03b0\u01d8\u0000\u1eb9\u1eba\u0003\u0420\u0210"+ + "\u0000\u1eba\u1ebb\u0003\u044a\u0225\u0000\u1ebb\u1ebc\u0003\u0396\u01cb"+ + "\u0000\u1ebc\u03af\u0001\u0000\u0000\u0000\u1ebd\u1ec2\u0003\u03b2\u01d9"+ + "\u0000\u1ebe\u1ebf\u0005\u0007\u0000\u0000\u1ebf\u1ec1\u0003\u03b2\u01d9"+ + "\u0000\u1ec0\u1ebe\u0001\u0000\u0000\u0000\u1ec1\u1ec4\u0001\u0000\u0000"+ + "\u0000\u1ec2\u1ec0\u0001\u0000\u0000\u0000\u1ec2\u1ec3\u0001\u0000\u0000"+ + "\u0000\u1ec3\u03b1\u0001\u0000\u0000\u0000\u1ec4\u1ec2\u0001\u0000\u0000"+ + "\u0000\u1ec5\u1ec6\u0003\u03b4\u01da\u0000\u1ec6\u1ec7\u0005\f\u0000\u0000"+ + "\u1ec7\u1ec8\u0003\u048c\u0246\u0000\u1ec8\u1ed0\u0001\u0000\u0000\u0000"+ + "\u1ec9\u1eca\u0005\u0003\u0000\u0000\u1eca\u1ecb\u0003\u03b6\u01db\u0000"+ + "\u1ecb\u1ecc\u0005\u0004\u0000\u0000\u1ecc\u1ecd\u0005\f\u0000\u0000\u1ecd"+ + "\u1ece\u0003\u048c\u0246\u0000\u1ece\u1ed0\u0001\u0000\u0000\u0000\u1ecf"+ + "\u1ec5\u0001\u0000\u0000\u0000\u1ecf\u1ec9\u0001\u0000\u0000\u0000\u1ed0"+ + "\u03b3\u0001\u0000\u0000\u0000\u1ed1\u1ed2\u0003\u055c\u02ae\u0000\u1ed2"+ + "\u1ed3\u0003\u052e\u0297\u0000\u1ed3\u03b5\u0001\u0000\u0000\u0000\u1ed4"+ + "\u1ed9\u0003\u03b4\u01da\u0000\u1ed5\u1ed6\u0005\u0007\u0000\u0000\u1ed6"+ + "\u1ed8\u0003\u03b4\u01da\u0000\u1ed7\u1ed5\u0001\u0000\u0000\u0000\u1ed8"+ + "\u1edb\u0001\u0000\u0000\u0000\u1ed9\u1ed7\u0001\u0000\u0000\u0000\u1ed9"+ + "\u1eda\u0001\u0000\u0000\u0000\u1eda\u03b7\u0001\u0000\u0000\u0000\u1edb"+ + "\u1ed9\u0001\u0000\u0000\u0000\u1edc\u1edd\u0005\u00b4\u0000\u0000\u1edd"+ + "\u1ede\u0003\u03ba\u01dd\u0000\u1ede\u1edf\u0003\u03bc\u01de\u0000\u1edf"+ + "\u1ee0\u0005\u00ae\u0000\u0000\u1ee0\u1ee1\u0003\u03be\u01df\u0000\u1ee1"+ + "\u1ee2\u0005@\u0000\u0000\u1ee2\u1ee3\u0003\u03c0\u01e0\u0000\u1ee3\u03b9"+ + "\u0001\u0000\u0000\u0000\u1ee4\u1ee5\u0003\u053c\u029e\u0000\u1ee5\u03bb"+ + "\u0001\u0000\u0000\u0000\u1ee6\u1ee7\u0005\u0108\u0000\u0000\u1ee7\u1eec"+ + "\u0005\u013f\u0000\u0000\u1ee8\u1eec\u0005\u013f\u0000\u0000\u1ee9\u1eec"+ + "\u0005m\u0000\u0000\u1eea\u1eec\u0005\u00e9\u0000\u0000\u1eeb\u1ee6\u0001"+ + "\u0000\u0000\u0000\u1eeb\u1ee8\u0001\u0000\u0000\u0000\u1eeb\u1ee9\u0001"+ + "\u0000\u0000\u0000\u1eeb\u1eea\u0001\u0000\u0000\u0000\u1eec\u1eef\u0001"+ + "\u0000\u0000\u0000\u1eed\u1eeb\u0001\u0000\u0000\u0000\u1eed\u1eee\u0001"+ + "\u0000\u0000\u0000\u1eee\u03bd\u0001\u0000\u0000\u0000\u1eef\u1eed\u0001"+ + "\u0000\u0000\u0000\u1ef0\u1ef6\u0001\u0000\u0000\u0000\u1ef1\u1ef2\u0005"+ + "k\u0000\u0000\u1ef2\u1ef6\u0005\u00db\u0000\u0000\u1ef3\u1ef4\u0005\u0176"+ + "\u0000\u0000\u1ef4\u1ef6\u0005\u00db\u0000\u0000\u1ef5\u1ef0\u0001\u0000"+ + "\u0000\u0000\u1ef5\u1ef1\u0001\u0000\u0000\u0000\u1ef5\u1ef3\u0001\u0000"+ + "\u0000\u0000\u1ef6\u03bf\u0001\u0000\u0000\u0000\u1ef7\u1efa\u0003\u03c4"+ + "\u01e2\u0000\u1ef8\u1efa\u0003\u03c2\u01e1\u0000\u1ef9\u1ef7\u0001\u0000"+ + "\u0000\u0000\u1ef9\u1ef8\u0001\u0000\u0000\u0000\u1efa\u03c1\u0001\u0000"+ + "\u0000\u0000\u1efb\u1efc\u0005\u0003\u0000\u0000\u1efc\u1efd\u0003\u03c4"+ + "\u01e2\u0000\u1efd\u1efe\u0005\u0004\u0000\u0000\u1efe\u1f04\u0001\u0000"+ + "\u0000\u0000\u1eff\u1f00\u0005\u0003\u0000\u0000\u1f00\u1f01\u0003\u03c2"+ + "\u01e1\u0000\u1f01\u1f02\u0005\u0004\u0000\u0000\u1f02\u1f04\u0001\u0000"+ + "\u0000\u0000\u1f03\u1efb\u0001\u0000\u0000\u0000\u1f03\u1eff\u0001\u0000"+ + "\u0000\u0000\u1f04\u03c3\u0001\u0000\u0000\u0000\u1f05\u1f06\u0003\u03c6"+ + "\u01e3\u0000\u1f06\u1f0d\u0003\u03e6\u01f3\u0000\u1f07\u1f08\u0003\u0412"+ + "\u0209\u0000\u1f08\u1f09\u0003\u03f0\u01f8\u0000\u1f09\u1f0e\u0001\u0000"+ + "\u0000\u0000\u1f0a\u1f0b\u0003\u03ee\u01f7\u0000\u1f0b\u1f0c\u0003\u0414"+ + "\u020a\u0000\u1f0c\u1f0e\u0001\u0000\u0000\u0000\u1f0d\u1f07\u0001\u0000"+ + "\u0000\u0000\u1f0d\u1f0a\u0001\u0000\u0000\u0000\u1f0d\u1f0e\u0001\u0000"+ + "\u0000\u0000\u1f0e\u1f1b\u0001\u0000\u0000\u0000\u1f0f\u1f10\u0003\u03ce"+ + "\u01e7\u0000\u1f10\u1f11\u0003\u03c6\u01e3\u0000\u1f11\u1f18\u0003\u03e6"+ + "\u01f3\u0000\u1f12\u1f13\u0003\u0412\u0209\u0000\u1f13\u1f14\u0003\u03f0"+ + "\u01f8\u0000\u1f14\u1f19\u0001\u0000\u0000\u0000\u1f15\u1f16\u0003\u03ee"+ + "\u01f7\u0000\u1f16\u1f17\u0003\u0414\u020a\u0000\u1f17\u1f19\u0001\u0000"+ + "\u0000\u0000\u1f18\u1f12\u0001\u0000\u0000\u0000\u1f18\u1f15\u0001\u0000"+ + "\u0000\u0000\u1f18\u1f19\u0001\u0000\u0000\u0000\u1f19\u1f1b\u0001\u0000"+ + "\u0000\u0000\u1f1a\u1f05\u0001\u0000\u0000\u0000\u1f1a\u1f0f\u0001\u0000"+ + "\u0000\u0000\u1f1b\u03c5\u0001\u0000\u0000\u0000\u1f1c\u1f23\u0003\u03c8"+ + "\u01e4\u0000\u1f1d\u1f1e\u0007%\u0000\u0000\u1f1e\u1f1f\u0003\u03e0\u01f0"+ + "\u0000\u1f1f\u1f20\u0003\u03c8\u01e4\u0000\u1f20\u1f22\u0001\u0000\u0000"+ + "\u0000\u1f21\u1f1d\u0001\u0000\u0000\u0000\u1f22\u1f25\u0001\u0000\u0000"+ + "\u0000\u1f23\u1f21\u0001\u0000\u0000\u0000\u1f23\u1f24\u0001\u0000\u0000"+ + "\u0000\u1f24\u03c7\u0001\u0000\u0000\u0000\u1f25\u1f23\u0001\u0000\u0000"+ + "\u0000\u1f26\u1f2d\u0003\u03ca\u01e5\u0000\u1f27\u1f28\u0005H\u0000\u0000"+ + "\u1f28\u1f29\u0003\u03e0\u01f0\u0000\u1f29\u1f2a\u0003\u03ca\u01e5\u0000"+ + "\u1f2a\u1f2c\u0001\u0000\u0000\u0000\u1f2b\u1f27\u0001\u0000\u0000\u0000"+ + "\u1f2c\u1f2f\u0001\u0000\u0000\u0000\u1f2d\u1f2b\u0001\u0000\u0000\u0000"+ + "\u1f2d\u1f2e\u0001\u0000\u0000\u0000\u1f2e\u03c9\u0001\u0000\u0000\u0000"+ + "\u1f2f\u1f2d\u0001\u0000\u0000\u0000\u1f30\u1f3b\u0005Z\u0000\u0000\u1f31"+ + "\u1f32\u0003\u03e4\u01f2\u0000\u1f32\u1f33\u0003\u03d8\u01ec\u0000\u1f33"+ + "\u1f34\u0003\u0530\u0298\u0000\u1f34\u1f3c\u0001\u0000\u0000\u0000\u1f35"+ + "\u1f36\u0003\u03e2\u01f1\u0000\u1f36\u1f37\u0003\u0532\u0299\u0000\u1f37"+ + "\u1f3c\u0001\u0000\u0000\u0000\u1f38\u1f39\u0003\u03cc\u01e6\u0000\u1f39"+ + "\u1f3a\u0003\u0530\u0298\u0000\u1f3a\u1f3c\u0001\u0000\u0000\u0000\u1f3b"+ + "\u1f31\u0001\u0000\u0000\u0000\u1f3b\u1f35\u0001\u0000\u0000\u0000\u1f3b"+ + "\u1f38\u0001\u0000\u0000\u0000\u1f3c\u1f3d\u0001\u0000\u0000\u0000\u1f3d"+ + "\u1f3e\u0003\u03d8\u01ec\u0000\u1f3e\u1f3f\u0003\u0420\u0210\u0000\u1f3f"+ + "\u1f40\u0003\u0448\u0224\u0000\u1f40\u1f41\u0003\u0402\u0201\u0000\u1f41"+ + "\u1f42\u0003\u0410\u0208\u0000\u1f42\u1f43\u0003\u04d8\u026c\u0000\u1f43"+ + "\u1f49\u0001\u0000\u0000\u0000\u1f44\u1f49\u0003\u041e\u020f\u0000\u1f45"+ + "\u1f46\u0005^\u0000\u0000\u1f46\u1f49\u0003\u0434\u021a\u0000\u1f47\u1f49"+ + "\u0003\u03c2\u01e1\u0000\u1f48\u1f30\u0001\u0000\u0000\u0000\u1f48\u1f44"+ + "\u0001\u0000\u0000\u0000\u1f48\u1f45\u0001\u0000\u0000\u0000\u1f48\u1f47"+ + "\u0001\u0000\u0000\u0000\u1f49\u03cb\u0001\u0000\u0000\u0000\u1f4a\u1f4b"+ + "\u0005\u020b\u0000\u0000\u1f4b\u1f4c\u0005\u0295\u0000\u0000\u1f4c\u03cd"+ + "\u0001\u0000\u0000\u0000\u1f4d\u1f4f\u0005k\u0000\u0000\u1f4e\u1f50\u0005"+ + "\u012a\u0000\u0000\u1f4f\u1f4e\u0001\u0000\u0000\u0000\u1f4f\u1f50\u0001"+ + "\u0000\u0000\u0000\u1f50\u1f51\u0001\u0000\u0000\u0000\u1f51\u1f52\u0003"+ + "\u03d0\u01e8\u0000\u1f52\u03cf\u0001\u0000\u0000\u0000\u1f53\u1f58\u0003"+ + "\u03d2\u01e9\u0000\u1f54\u1f55\u0005\u0007\u0000\u0000\u1f55\u1f57\u0003"+ + "\u03d2\u01e9\u0000\u1f56\u1f54\u0001\u0000\u0000\u0000\u1f57\u1f5a\u0001"+ + "\u0000\u0000\u0000\u1f58\u1f56\u0001\u0000\u0000\u0000\u1f58\u1f59\u0001"+ + "\u0000\u0000\u0000\u1f59\u03d1\u0001\u0000\u0000\u0000\u1f5a\u1f58\u0001"+ + "\u0000\u0000\u0000\u1f5b\u1f5c\u0003\u053c\u029e\u0000\u1f5c\u1f5d\u0003"+ + "\u0366\u01b3\u0000\u1f5d\u1f5e\u0005&\u0000\u0000\u1f5e\u1f5f\u0003\u03d4"+ + "\u01ea\u0000\u1f5f\u1f60\u0005\u0003\u0000\u0000\u1f60\u1f61\u0003\u037e"+ + "\u01bf\u0000\u1f61\u1f62\u0005\u0004\u0000\u0000\u1f62\u03d3\u0001\u0000"+ + "\u0000\u0000\u1f63\u1f68\u0005\u00fd\u0000\u0000\u1f64\u1f65\u0005O\u0000"+ + "\u0000\u1f65\u1f68\u0005\u00fd\u0000\u0000\u1f66\u1f68\u0001\u0000\u0000"+ + "\u0000\u1f67\u1f63\u0001\u0000\u0000\u0000\u1f67\u1f64\u0001\u0000\u0000"+ + "\u0000\u1f67\u1f66\u0001\u0000\u0000\u0000\u1f68\u03d5\u0001\u0000\u0000"+ + "\u0000\u1f69\u1f6c\u0003\u03ce\u01e7\u0000\u1f6a\u1f6c\u0001\u0000\u0000"+ + "\u0000\u1f6b\u1f69\u0001\u0000\u0000\u0000\u1f6b\u1f6a\u0001\u0000\u0000"+ + "\u0000\u1f6c\u03d7\u0001\u0000\u0000\u0000\u1f6d\u1f72\u0005I\u0000\u0000"+ + "\u1f6e\u1f6f\u0003\u03da\u01ed\u0000\u1f6f\u1f70\u0003\u03dc\u01ee\u0000"+ + "\u1f70\u1f73\u0001\u0000\u0000\u0000\u1f71\u1f73\u0003\u061e\u030f\u0000"+ + "\u1f72\u1f6e\u0001\u0000\u0000\u0000\u1f72\u1f71\u0001\u0000\u0000\u0000"+ + "\u1f73\u1f76\u0001\u0000\u0000\u0000\u1f74\u1f76\u0001\u0000\u0000\u0000"+ + "\u1f75\u1f6d\u0001\u0000\u0000\u0000\u1f75\u1f74\u0001\u0000\u0000\u0000"+ + "\u1f76\u03d9\u0001\u0000\u0000\u0000\u1f77\u1f7a\u0001\u0000\u0000\u0000"+ + "\u1f78\u1f7a\u0005\u0155\u0000\u0000\u1f79\u1f77\u0001\u0000\u0000\u0000"+ + "\u1f79\u1f78\u0001\u0000\u0000\u0000\u1f7a\u03db\u0001\u0000\u0000\u0000"+ + "\u1f7b\u1f7d\u0007&\u0000\u0000\u1f7c\u1f7b\u0001\u0000\u0000\u0000\u1f7c"+ + "\u1f7d\u0001\u0000\u0000\u0000\u1f7d\u1f7e\u0001\u0000\u0000\u0000\u1f7e"+ + "\u1f7f\u0007\u000b\u0000\u0000\u1f7f\u1f80\u0003\u03de\u01ef\u0000\u1f80"+ + "\u1f81\u0003\u0538\u029c\u0000\u1f81\u1f8a\u0001\u0000\u0000\u0000\u1f82"+ + "\u1f83\u0005\u016a\u0000\u0000\u1f83\u1f84\u0003\u03de\u01ef\u0000\u1f84"+ + "\u1f85\u0003\u0538\u029c\u0000\u1f85\u1f8a\u0001\u0000\u0000\u0000\u1f86"+ + "\u1f87\u0005^\u0000\u0000\u1f87\u1f8a\u0003\u0538\u029c\u0000\u1f88\u1f8a"+ + "\u0003\u0538\u029c\u0000\u1f89\u1f7c\u0001\u0000\u0000\u0000\u1f89\u1f82"+ + "\u0001\u0000\u0000\u0000\u1f89\u1f86\u0001\u0000\u0000\u0000\u1f89\u1f88"+ + "\u0001\u0000\u0000\u0000\u1f8a\u03dd\u0001\u0000\u0000\u0000\u1f8b\u1f8e"+ + "\u0005^\u0000\u0000\u1f8c\u1f8e\u0001\u0000\u0000\u0000\u1f8d\u1f8b\u0001"+ + "\u0000\u0000\u0000\u1f8d\u1f8c\u0001\u0000\u0000\u0000\u1f8e\u03df\u0001"+ + "\u0000\u0000\u0000\u1f8f\u1f93\u0005 \u0000\u0000\u1f90\u1f93\u0005:\u0000"+ + "\u0000\u1f91\u1f93\u0001\u0000\u0000\u0000\u1f92\u1f8f\u0001\u0000\u0000"+ + "\u0000\u1f92\u1f90\u0001\u0000\u0000\u0000\u1f92\u1f91\u0001\u0000\u0000"+ + "\u0000\u1f93\u03e1\u0001\u0000\u0000\u0000\u1f94\u1f9a\u0005:\u0000\u0000"+ + "\u1f95\u1f96\u0005R\u0000\u0000\u1f96\u1f97\u0005\u0003\u0000\u0000\u1f97"+ + "\u1f98\u0003\u0500\u0280\u0000\u1f98\u1f99\u0005\u0004\u0000\u0000\u1f99"+ + "\u1f9b\u0001\u0000\u0000\u0000\u1f9a\u1f95\u0001\u0000\u0000\u0000\u1f9a"+ + "\u1f9b\u0001\u0000\u0000\u0000\u1f9b\u03e3\u0001\u0000\u0000\u0000\u1f9c"+ + "\u1f9f\u0005 \u0000\u0000\u1f9d\u1f9f\u0001\u0000\u0000\u0000\u1f9e\u1f9c"+ + "\u0001\u0000\u0000\u0000\u1f9e\u1f9d\u0001\u0000\u0000\u0000\u1f9f\u03e5"+ + "\u0001\u0000\u0000\u0000\u1fa0\u1fa3\u0003\u03e8\u01f4\u0000\u1fa1\u1fa3"+ + "\u0001\u0000\u0000\u0000\u1fa2\u1fa0\u0001\u0000\u0000\u0000\u1fa2\u1fa1"+ + "\u0001\u0000\u0000\u0000\u1fa3\u03e7\u0001\u0000\u0000\u0000\u1fa4\u1fa5"+ + "\u0005U\u0000\u0000\u1fa5\u1fa6\u0005\u0095\u0000\u0000\u1fa6\u1fa7\u0003"+ + "\u03ea\u01f5\u0000\u1fa7\u03e9\u0001\u0000\u0000\u0000\u1fa8\u1fad\u0003"+ + "\u03ec\u01f6\u0000\u1fa9\u1faa\u0005\u0007\u0000\u0000\u1faa\u1fac\u0003"+ + "\u03ec\u01f6\u0000\u1fab\u1fa9\u0001\u0000\u0000\u0000\u1fac\u1faf\u0001"+ + "\u0000\u0000\u0000\u1fad\u1fab\u0001\u0000\u0000\u0000\u1fad\u1fae\u0001"+ + "\u0000\u0000\u0000\u1fae\u03eb\u0001\u0000\u0000\u0000\u1faf\u1fad\u0001"+ + "\u0000\u0000\u0000\u1fb0\u1fb4\u0003\u048c\u0246\u0000\u1fb1\u1fb2\u0005"+ + "f\u0000\u0000\u1fb2\u1fb5\u0003\u04fc\u027e\u0000\u1fb3\u1fb5\u0003\u0264"+ + "\u0132\u0000\u1fb4\u1fb1\u0001\u0000\u0000\u0000\u1fb4\u1fb3\u0001\u0000"+ + "\u0000\u0000\u1fb5\u1fb6\u0001\u0000\u0000\u0000\u1fb6\u1fb7\u0003\u0266"+ + "\u0133\u0000\u1fb7\u03ed\u0001\u0000\u0000\u0000\u1fb8\u1fba\u0003\u03f2"+ + "\u01f9\u0000\u1fb9\u1fbb\u0003\u03f4\u01fa\u0000\u1fba\u1fb9\u0001\u0000"+ + "\u0000\u0000\u1fba\u1fbb\u0001\u0000\u0000\u0000\u1fbb\u1fc1\u0001\u0000"+ + "\u0000\u0000\u1fbc\u1fbe\u0003\u03f4\u01fa\u0000\u1fbd\u1fbf\u0003\u03f2"+ + "\u01f9\u0000\u1fbe\u1fbd\u0001\u0000\u0000\u0000\u1fbe\u1fbf\u0001\u0000"+ + "\u0000\u0000\u1fbf\u1fc1\u0001\u0000\u0000\u0000\u1fc0\u1fb8\u0001\u0000"+ + "\u0000\u0000\u1fc0\u1fbc\u0001\u0000\u0000\u0000\u1fc1\u03ef\u0001\u0000"+ + "\u0000\u0000\u1fc2\u1fc5\u0003\u03ee\u01f7\u0000\u1fc3\u1fc5\u0001\u0000"+ + "\u0000\u0000\u1fc4\u1fc2\u0001\u0000\u0000\u0000\u1fc4\u1fc3\u0001\u0000"+ + "\u0000\u0000\u1fc5\u03f1\u0001\u0000\u0000\u0000\u1fc6\u1fc7\u0005L\u0000"+ + "\u0000\u1fc7\u1fca\u0003\u03f6\u01fb\u0000\u1fc8\u1fc9\u0005\u0007\u0000"+ + "\u0000\u1fc9\u1fcb\u0003\u03f8\u01fc\u0000\u1fca\u1fc8\u0001\u0000\u0000"+ + "\u0000\u1fca\u1fcb\u0001\u0000\u0000\u0000\u1fcb\u1fde\u0001\u0000\u0000"+ + "\u0000\u1fcc\u1fcd\u0005?\u0000\u0000\u1fcd\u1fdb\u0003\u0400\u0200\u0000"+ + "\u1fce\u1fcf\u0003\u03fa\u01fd\u0000\u1fcf\u1fd3\u0003\u03fe\u01ff\u0000"+ + "\u1fd0\u1fd4\u0005S\u0000\u0000\u1fd1\u1fd2\u0005k\u0000\u0000\u1fd2\u1fd4"+ + "\u0005\u01d5\u0000\u0000\u1fd3\u1fd0\u0001\u0000\u0000\u0000\u1fd3\u1fd1"+ + "\u0001\u0000\u0000\u0000\u1fd4\u1fdc\u0001\u0000\u0000\u0000\u1fd5\u1fd9"+ + "\u0003\u03fe\u01ff\u0000\u1fd6\u1fda\u0005S\u0000\u0000\u1fd7\u1fd8\u0005"+ + "k\u0000\u0000\u1fd8\u1fda\u0005\u01d5\u0000\u0000\u1fd9\u1fd6\u0001\u0000"+ + "\u0000\u0000\u1fd9\u1fd7\u0001\u0000\u0000\u0000\u1fda\u1fdc\u0001\u0000"+ + "\u0000\u0000\u1fdb\u1fce\u0001\u0000\u0000\u0000\u1fdb\u1fd5\u0001\u0000"+ + "\u0000\u0000\u1fdc\u1fde\u0001\u0000\u0000\u0000\u1fdd\u1fc6\u0001\u0000"+ + "\u0000\u0000\u1fdd\u1fcc\u0001\u0000\u0000\u0000\u1fde\u03f3\u0001\u0000"+ + "\u0000\u0000\u1fdf\u1fe4\u0005Q\u0000\u0000\u1fe0\u1fe5\u0003\u03f8\u01fc"+ + "\u0000\u1fe1\u1fe2\u0003\u03fa\u01fd\u0000\u1fe2\u1fe3\u0003\u03fe\u01ff"+ + "\u0000\u1fe3\u1fe5\u0001\u0000\u0000\u0000\u1fe4\u1fe0\u0001\u0000\u0000"+ + "\u0000\u1fe4\u1fe1\u0001\u0000\u0000\u0000\u1fe5\u03f5\u0001\u0000\u0000"+ + "\u0000\u1fe6\u1fe9\u0003\u048c\u0246\u0000\u1fe7\u1fe9\u0005 \u0000\u0000"+ + "\u1fe8\u1fe6\u0001\u0000\u0000\u0000\u1fe8\u1fe7\u0001\u0000\u0000\u0000"+ + "\u1fe9\u03f7\u0001\u0000\u0000\u0000\u1fea\u1feb\u0003\u048c\u0246\u0000"+ + "\u1feb\u03f9\u0001\u0000\u0000\u0000\u1fec\u1ff2\u0003\u04b8\u025c\u0000"+ + "\u1fed\u1fee\u0005\u000e\u0000\u0000\u1fee\u1ff2\u0003\u03fc\u01fe\u0000"+ + "\u1fef\u1ff0\u0005\u000f\u0000\u0000\u1ff0\u1ff2\u0003\u03fc\u01fe\u0000"+ + "\u1ff1\u1fec\u0001\u0000\u0000\u0000\u1ff1\u1fed\u0001\u0000\u0000\u0000"+ + "\u1ff1\u1fef\u0001\u0000\u0000\u0000\u1ff2\u03fb\u0001\u0000\u0000\u0000"+ + "\u1ff3\u1ff6\u0003\u054c\u02a6\u0000\u1ff4\u1ff6\u0003\u054a\u02a5\u0000"+ + "\u1ff5\u1ff3\u0001\u0000\u0000\u0000\u1ff5\u1ff4\u0001\u0000\u0000\u0000"+ + "\u1ff6\u03fd\u0001\u0000\u0000\u0000\u1ff7\u1ff8\u0007\'\u0000\u0000\u1ff8"+ + "\u03ff\u0001\u0000\u0000\u0000\u1ff9\u1ffa\u0007(\u0000\u0000\u1ffa\u0401"+ + "\u0001\u0000\u0000\u0000\u1ffb\u1ffc\u0005D\u0000\u0000\u1ffc\u1ffd\u0005"+ + "\u0095\u0000\u0000\u1ffd\u2000\u0003\u0404\u0202\u0000\u1ffe\u2000\u0001"+ + "\u0000\u0000\u0000\u1fff\u1ffb\u0001\u0000\u0000\u0000\u1fff\u1ffe\u0001"+ + "\u0000\u0000\u0000\u2000\u0403\u0001\u0000\u0000\u0000\u2001\u2006\u0003"+ + "\u0406\u0203\u0000\u2002\u2003\u0005\u0007\u0000\u0000\u2003\u2005\u0003"+ + "\u0406\u0203\u0000\u2004\u2002\u0001\u0000\u0000\u0000\u2005\u2008\u0001"+ + "\u0000\u0000\u0000\u2006\u2004\u0001\u0000\u0000\u0000\u2006\u2007\u0001"+ + "\u0000\u0000\u0000\u2007\u0405\u0001\u0000\u0000\u0000\u2008\u2006\u0001"+ + "\u0000\u0000\u0000\u2009\u200f\u0003\u0408\u0204\u0000\u200a\u200f\u0003"+ + "\u040c\u0206\u0000\u200b\u200f\u0003\u040a\u0205\u0000\u200c\u200f\u0003"+ + "\u040e\u0207\u0000\u200d\u200f\u0003\u048c\u0246\u0000\u200e\u2009\u0001"+ + "\u0000\u0000\u0000\u200e\u200a\u0001\u0000\u0000\u0000\u200e\u200b\u0001"+ + "\u0000\u0000\u0000\u200e\u200c\u0001\u0000\u0000\u0000\u200e\u200d\u0001"+ + "\u0000\u0000\u0000\u200f\u0407\u0001\u0000\u0000\u0000\u2010\u2011\u0005"+ + "\u0003\u0000\u0000\u2011\u2012\u0005\u0004\u0000\u0000\u2012\u0409\u0001"+ + "\u0000\u0000\u0000\u2013\u2014\u0005\u01d6\u0000\u0000\u2014\u2015\u0005"+ + "\u0003\u0000\u0000\u2015\u2016\u0003\u0500\u0280\u0000\u2016\u2017\u0005"+ + "\u0004\u0000\u0000\u2017\u040b\u0001\u0000\u0000\u0000\u2018\u2019\u0005"+ + "\u01d7\u0000\u0000\u2019\u201a\u0005\u0003\u0000\u0000\u201a\u201b\u0003"+ + "\u0500\u0280\u0000\u201b\u201c\u0005\u0004\u0000\u0000\u201c\u040d\u0001"+ + "\u0000\u0000\u0000\u201d\u201e\u0005\u01d8\u0000\u0000\u201e\u201f\u0005"+ + "\u01d9\u0000\u0000\u201f\u2020\u0005\u0003\u0000\u0000\u2020\u2021\u0003"+ + "\u0404\u0202\u0000\u2021\u2022\u0005\u0004\u0000\u0000\u2022\u040f\u0001"+ + "\u0000\u0000\u0000\u2023\u2024\u0005E\u0000\u0000\u2024\u2027\u0003\u048c"+ + "\u0246\u0000\u2025\u2027\u0001\u0000\u0000\u0000\u2026\u2023\u0001\u0000"+ + "\u0000\u0000\u2026\u2025\u0001\u0000\u0000\u0000\u2027\u0411\u0001\u0000"+ + "\u0000\u0000\u2028\u202d\u0003\u0416\u020b\u0000\u2029\u202a\u0005@\u0000"+ + "\u0000\u202a\u202b\u0005\u0127\u0000\u0000\u202b\u202d\u0005S\u0000\u0000"+ + "\u202c\u2028\u0001\u0000\u0000\u0000\u202c\u2029\u0001\u0000\u0000\u0000"+ + "\u202d\u0413\u0001\u0000\u0000\u0000\u202e\u2031\u0003\u0412\u0209\u0000"+ + "\u202f\u2031\u0001\u0000\u0000\u0000\u2030\u202e\u0001\u0000\u0000\u0000"+ + "\u2030\u202f\u0001\u0000\u0000\u0000\u2031\u0415\u0001\u0000\u0000\u0000"+ + "\u2032\u2034\u0003\u0418\u020c\u0000\u2033\u2032\u0001\u0000\u0000\u0000"+ + "\u2034\u2035\u0001\u0000\u0000\u0000\u2035\u2033\u0001\u0000\u0000\u0000"+ + "\u2035\u2036\u0001\u0000\u0000\u0000\u2036\u0417\u0001\u0000\u0000\u0000"+ + "\u2037\u2038\u0003\u041a\u020d\u0000\u2038\u2039\u0003\u041c\u020e\u0000"+ + "\u2039\u203a\u0003\u03ac\u01d6\u0000\u203a\u0419\u0001\u0000\u0000\u0000"+ + "\u203b\u2045\u0005@\u0000\u0000\u203c\u203d\u0005\u0108\u0000\u0000\u203d"+ + "\u203f\u0005\u00ee\u0000\u0000\u203e\u203c\u0001\u0000\u0000\u0000\u203e"+ + "\u203f\u0001\u0000\u0000\u0000\u203f\u2040\u0001\u0000\u0000\u0000\u2040"+ + "\u2046\u0005\u016c\u0000\u0000\u2041\u2043\u0005\u00ee\u0000\u0000\u2042"+ + "\u2041\u0001\u0000\u0000\u0000\u2042\u2043\u0001\u0000\u0000\u0000\u2043"+ + "\u2044\u0001\u0000\u0000\u0000\u2044\u2046\u0005\u0149\u0000\u0000\u2045"+ + "\u203e\u0001\u0000\u0000\u0000\u2045\u2042\u0001\u0000\u0000\u0000\u2046"+ + "\u041b\u0001\u0000\u0000\u0000\u2047\u2048\u0005\u010e\u0000\u0000\u2048"+ + "\u204b\u0003\u0536\u029b\u0000\u2049\u204b\u0001\u0000\u0000\u0000\u204a"+ + "\u2047\u0001\u0000\u0000\u0000\u204a\u2049\u0001\u0000\u0000\u0000\u204b"+ + "\u041d\u0001\u0000\u0000\u0000\u204c\u204d\u0005\u01a1\u0000\u0000\u204d"+ + "\u204e\u0005\u0003\u0000\u0000\u204e\u204f\u0003\u0500\u0280\u0000\u204f"+ + "\u2057\u0005\u0004\u0000\u0000\u2050\u2051\u0005\u0007\u0000\u0000\u2051"+ + "\u2052\u0005\u0003\u0000\u0000\u2052\u2053\u0003\u0500\u0280\u0000\u2053"+ + "\u2054\u0005\u0004\u0000\u0000\u2054\u2056\u0001\u0000\u0000\u0000\u2055"+ + "\u2050\u0001\u0000\u0000\u0000\u2056\u2059\u0001\u0000\u0000\u0000\u2057"+ + "\u2055\u0001\u0000\u0000\u0000\u2057\u2058\u0001\u0000\u0000\u0000\u2058"+ + "\u041f\u0001\u0000\u0000\u0000\u2059\u2057\u0001\u0000\u0000\u0000\u205a"+ + "\u205b\u0005B\u0000\u0000\u205b\u205e\u0003\u0422\u0211\u0000\u205c\u205e"+ + "\u0001\u0000\u0000\u0000\u205d\u205a\u0001\u0000\u0000\u0000\u205d\u205c"+ + "\u0001\u0000\u0000\u0000\u205e\u0421\u0001\u0000\u0000\u0000\u205f\u2069"+ + "\u0003\u0424\u0212\u0000\u2060\u2065\u0003\u0426\u0213\u0000\u2061\u2062"+ + "\u0005\u0007\u0000\u0000\u2062\u2064\u0003\u0426\u0213\u0000\u2063\u2061"+ + "\u0001\u0000\u0000\u0000\u2064\u2067\u0001\u0000\u0000\u0000\u2065\u2063"+ + "\u0001\u0000\u0000\u0000\u2065\u2066\u0001\u0000\u0000\u0000\u2066\u2069"+ + "\u0001\u0000\u0000\u0000\u2067\u2065\u0001\u0000\u0000\u0000\u2068\u205f"+ + "\u0001\u0000\u0000\u0000\u2068\u2060\u0001\u0000\u0000\u0000\u2069\u0423"+ + "\u0001\u0000\u0000\u0000\u206a\u206d\u0003\u0426\u0213\u0000\u206b\u206c"+ + "\u0005\u0007\u0000\u0000\u206c\u206e\u0003\u0426\u0213\u0000\u206d\u206b"+ + "\u0001\u0000\u0000\u0000\u206e\u206f\u0001\u0000\u0000\u0000\u206f\u206d"+ + "\u0001\u0000\u0000\u0000\u206f\u2070\u0001\u0000\u0000\u0000\u2070\u0425"+ + "\u0001\u0000\u0000\u0000\u2071\u2072\u0003\u0434\u021a\u0000\u2072\u2074"+ + "\u0003\u042a\u0215\u0000\u2073\u2075\u0003\u043a\u021d\u0000\u2074\u2073"+ + "\u0001\u0000\u0000\u0000\u2074\u2075\u0001\u0000\u0000\u0000\u2075\u20a3"+ + "\u0001\u0000\u0000\u0000\u2076\u2077\u0003\u043e\u021f\u0000\u2077\u2078"+ + "\u0003\u042e\u0217\u0000\u2078\u20a3\u0001\u0000\u0000\u0000\u2079\u207a"+ + "\u0003\u0452\u0229\u0000\u207a\u207b\u0003\u042a\u0215\u0000\u207b\u20a3"+ + "\u0001\u0000\u0000\u0000\u207c\u207d\u0003\u03c2\u01e1\u0000\u207d\u207e"+ + "\u0003\u042a\u0215\u0000\u207e\u20a3\u0001\u0000\u0000\u0000\u207f\u2089"+ + "\u0005J\u0000\u0000\u2080\u2081\u0003\u0452\u0229\u0000\u2081\u2082\u0003"+ + "\u042a\u0215\u0000\u2082\u208a\u0001\u0000\u0000\u0000\u2083\u2084\u0003"+ + "\u043e\u021f\u0000\u2084\u2085\u0003\u042e\u0217\u0000\u2085\u208a\u0001"+ + "\u0000\u0000\u0000\u2086\u2087\u0003\u03c2\u01e1\u0000\u2087\u2088\u0003"+ + "\u042a\u0215\u0000\u2088\u208a\u0001\u0000\u0000\u0000\u2089\u2080\u0001"+ + "\u0000\u0000\u0000\u2089\u2083\u0001\u0000\u0000\u0000\u2089\u2086\u0001"+ + "\u0000\u0000\u0000\u208a\u20a3\u0001\u0000\u0000\u0000\u208b\u208c\u0005"+ + "\u0003\u0000\u0000\u208c\u209d\u0003\u0426\u0213\u0000\u208d\u208e\u0005"+ + "p\u0000\u0000\u208e\u208f\u0005x\u0000\u0000\u208f\u209e\u0003\u0426\u0213"+ + "\u0000\u2090\u2092\u0005{\u0000\u0000\u2091\u2093\u0003\u0430\u0218\u0000"+ + "\u2092\u2091\u0001\u0000\u0000\u0000\u2092\u2093\u0001\u0000\u0000\u0000"+ + "\u2093\u2094\u0001\u0000\u0000\u0000\u2094\u2095\u0005x\u0000\u0000\u2095"+ + "\u209e\u0003\u0426\u0213\u0000\u2096\u2098\u0003\u0430\u0218\u0000\u2097"+ + "\u2096\u0001\u0000\u0000\u0000\u2097\u2098\u0001\u0000\u0000\u0000\u2098"+ + "\u2099\u0001\u0000\u0000\u0000\u2099\u209a\u0005x\u0000\u0000\u209a\u209b"+ + "\u0003\u0426\u0213\u0000\u209b\u209c\u0003\u0432\u0219\u0000\u209c\u209e"+ + "\u0001\u0000\u0000\u0000\u209d\u208d\u0001\u0000\u0000\u0000\u209d\u2090"+ + "\u0001\u0000\u0000\u0000\u209d\u2097\u0001\u0000\u0000\u0000\u209d\u209e"+ + "\u0001\u0000\u0000\u0000\u209e\u209f\u0001\u0000\u0000\u0000\u209f\u20a0"+ + "\u0005\u0004\u0000\u0000\u20a0\u20a1\u0003\u042a\u0215\u0000\u20a1\u20a3"+ + "\u0001\u0000\u0000\u0000\u20a2\u2071\u0001\u0000\u0000\u0000\u20a2\u2076"+ + "\u0001\u0000\u0000\u0000\u20a2\u2079\u0001\u0000\u0000\u0000\u20a2\u207c"+ + "\u0001\u0000\u0000\u0000\u20a2\u207f\u0001\u0000\u0000\u0000\u20a2\u208b"+ + "\u0001\u0000\u0000\u0000\u20a3\u20b6\u0001\u0000\u0000\u0000\u20a4\u20a5"+ + "\u0005p\u0000\u0000\u20a5\u20a6\u0005x\u0000\u0000\u20a6\u20b5\u0003\u0426"+ + "\u0213\u0000\u20a7\u20a9\u0005{\u0000\u0000\u20a8\u20aa\u0003\u0430\u0218"+ + "\u0000\u20a9\u20a8\u0001\u0000\u0000\u0000\u20a9\u20aa\u0001\u0000\u0000"+ + "\u0000\u20aa\u20ab\u0001\u0000\u0000\u0000\u20ab\u20ac\u0005x\u0000\u0000"+ + "\u20ac\u20b5\u0003\u0426\u0213\u0000\u20ad\u20af\u0003\u0430\u0218\u0000"+ + "\u20ae\u20ad\u0001\u0000\u0000\u0000\u20ae\u20af\u0001\u0000\u0000\u0000"+ + "\u20af\u20b0\u0001\u0000\u0000\u0000\u20b0\u20b1\u0005x\u0000\u0000\u20b1"+ + "\u20b2\u0003\u0426\u0213\u0000\u20b2\u20b3\u0003\u0432\u0219\u0000\u20b3"+ + "\u20b5\u0001\u0000\u0000\u0000\u20b4\u20a4\u0001\u0000\u0000\u0000\u20b4"+ + "\u20a7\u0001\u0000\u0000\u0000\u20b4\u20ae\u0001\u0000\u0000\u0000\u20b5"+ + "\u20b8\u0001\u0000\u0000\u0000\u20b6\u20b4\u0001\u0000\u0000\u0000\u20b6"+ + "\u20b7\u0001\u0000\u0000\u0000\u20b7\u0427\u0001\u0000\u0000\u0000\u20b8"+ + "\u20b6\u0001\u0000\u0000\u0000\u20b9\u20bb\u0005&\u0000\u0000\u20ba\u20b9"+ + "\u0001\u0000\u0000\u0000\u20ba\u20bb\u0001\u0000\u0000\u0000\u20bb\u20bc"+ + "\u0001\u0000\u0000\u0000\u20bc\u20c1\u0003\u055c\u02ae\u0000\u20bd\u20be"+ + "\u0005\u0003\u0000\u0000\u20be\u20bf\u0003\u053a\u029d\u0000\u20bf\u20c0"+ + "\u0005\u0004\u0000\u0000\u20c0\u20c2\u0001\u0000\u0000\u0000\u20c1\u20bd"+ + "\u0001\u0000\u0000\u0000\u20c1\u20c2\u0001\u0000\u0000\u0000\u20c2\u0429"+ + "\u0001\u0000\u0000\u0000\u20c3\u20c6\u0003\u042c\u0216\u0000\u20c4\u20c6"+ + "\u0001\u0000\u0000\u0000\u20c5\u20c3\u0001\u0000\u0000\u0000\u20c5\u20c4"+ + "\u0001\u0000\u0000\u0000\u20c6\u042b\u0001\u0000\u0000\u0000\u20c7\u20c9"+ + "\u0005&\u0000\u0000\u20c8\u20c7\u0001\u0000\u0000\u0000\u20c8\u20c9\u0001"+ + "\u0000\u0000\u0000\u20c9\u20ca\u0001\u0000\u0000\u0000\u20ca\u20cf\u0003"+ + "\u055e\u02af\u0000\u20cb\u20cc\u0005\u0003\u0000\u0000\u20cc\u20cd\u0003"+ + "\u053a\u029d\u0000\u20cd\u20ce\u0005\u0004\u0000\u0000\u20ce\u20d0\u0001"+ + "\u0000\u0000\u0000\u20cf\u20cb\u0001\u0000\u0000\u0000\u20cf\u20d0\u0001"+ + "\u0000\u0000\u0000\u20d0\u042d\u0001\u0000\u0000\u0000\u20d1\u20df\u0003"+ + "\u0428\u0214\u0000\u20d2\u20d4\u0005&\u0000\u0000\u20d3\u20d5\u0003\u055c"+ + "\u02ae\u0000\u20d4\u20d3\u0001\u0000\u0000\u0000\u20d4\u20d5\u0001\u0000"+ + "\u0000\u0000\u20d5\u20d8\u0001\u0000\u0000\u0000\u20d6\u20d8\u0003\u055c"+ + "\u02ae\u0000\u20d7\u20d2\u0001\u0000\u0000\u0000\u20d7\u20d6\u0001\u0000"+ + "\u0000\u0000\u20d8\u20d9\u0001\u0000\u0000\u0000\u20d9\u20da\u0005\u0003"+ + "\u0000\u0000\u20da\u20db\u0003\u044e\u0227\u0000\u20db\u20dc\u0005\u0004"+ + "\u0000\u0000\u20dc\u20df\u0001\u0000\u0000\u0000\u20dd\u20df\u0001\u0000"+ + "\u0000\u0000\u20de\u20d1\u0001\u0000\u0000\u0000\u20de\u20d7\u0001\u0000"+ + "\u0000\u0000\u20de\u20dd\u0001\u0000\u0000\u0000\u20df\u042f\u0001\u0000"+ + "\u0000\u0000\u20e0\u20e2\u0007)\u0000\u0000\u20e1\u20e3\u0005}\u0000\u0000"+ + "\u20e2\u20e1\u0001\u0000\u0000\u0000\u20e2\u20e3\u0001\u0000\u0000\u0000"+ + "\u20e3\u0431\u0001\u0000\u0000\u0000\u20e4\u20e5\u0005f\u0000\u0000\u20e5"+ + "\u20e6\u0005\u0003\u0000\u0000\u20e6\u20e7\u0003\u053a\u029d\u0000\u20e7"+ + "\u20e8\u0005\u0004\u0000\u0000\u20e8\u20ec\u0001\u0000\u0000\u0000\u20e9"+ + "\u20ea\u0005R\u0000\u0000\u20ea\u20ec\u0003\u048c\u0246\u0000\u20eb\u20e4"+ + "\u0001\u0000\u0000\u0000\u20eb\u20e9\u0001\u0000\u0000\u0000\u20ec\u0433"+ + "\u0001\u0000\u0000\u0000\u20ed\u20ef\u0003\u0538\u029c\u0000\u20ee\u20f0"+ + "\u0005\u000b\u0000\u0000\u20ef\u20ee\u0001\u0000\u0000\u0000\u20ef\u20f0"+ + "\u0001\u0000\u0000\u0000\u20f0\u20fa\u0001\u0000\u0000\u0000\u20f1\u20f7"+ + "\u0005S\u0000\u0000\u20f2\u20f8\u0003\u0538\u029c\u0000\u20f3\u20f4\u0005"+ + "\u0003\u0000\u0000\u20f4\u20f5\u0003\u0538\u029c\u0000\u20f5\u20f6\u0005"+ + "\u0004\u0000\u0000\u20f6\u20f8\u0001\u0000\u0000\u0000\u20f7\u20f2\u0001"+ + "\u0000\u0000\u0000\u20f7\u20f3\u0001\u0000\u0000\u0000\u20f8\u20fa\u0001"+ + "\u0000\u0000\u0000\u20f9\u20ed\u0001\u0000\u0000\u0000\u20f9\u20f1\u0001"+ + "\u0000\u0000\u0000\u20fa\u0435\u0001\u0000\u0000\u0000\u20fb\u2100\u0003"+ + "\u0434\u021a\u0000\u20fc\u20fd\u0005\u0007\u0000\u0000\u20fd\u20ff\u0003"+ + "\u0434\u021a\u0000\u20fe\u20fc\u0001\u0000\u0000\u0000\u20ff\u2102\u0001"+ + "\u0000\u0000\u0000\u2100\u20fe\u0001\u0000\u0000\u0000\u2100\u2101\u0001"+ + "\u0000\u0000\u0000\u2101\u0437\u0001\u0000\u0000\u0000\u2102\u2100\u0001"+ + "\u0000\u0000\u0000\u2103\u2108\u0003\u0434\u021a\u0000\u2104\u2106\u0005"+ + "&\u0000\u0000\u2105\u2104\u0001\u0000\u0000\u0000\u2105\u2106\u0001\u0000"+ + "\u0000\u0000\u2106\u2107\u0001\u0000\u0000\u0000\u2107\u2109\u0003\u055c"+ + "\u02ae\u0000\u2108\u2105\u0001\u0000\u0000\u0000\u2108\u2109\u0001\u0000"+ + "\u0000\u0000\u2109\u0439\u0001\u0000\u0000\u0000\u210a\u210b\u0005\u01da"+ + "\u0000\u0000\u210b\u210c\u0003\u0542\u02a1\u0000\u210c\u210d\u0005\u0003"+ + "\u0000\u0000\u210d\u210e\u0003\u0500\u0280\u0000\u210e\u210f\u0005\u0004"+ + "\u0000\u0000\u210f\u2110\u0003\u043c\u021e\u0000\u2110\u043b\u0001\u0000"+ + "\u0000\u0000\u2111\u2112\u0005\u0131\u0000\u0000\u2112\u2113\u0005\u0003"+ + "\u0000\u0000\u2113\u2114\u0003\u048c\u0246\u0000\u2114\u2115\u0005\u0004"+ + "\u0000\u0000\u2115\u2118\u0001\u0000\u0000\u0000\u2116\u2118\u0001\u0000"+ + "\u0000\u0000\u2117\u2111\u0001\u0000\u0000\u0000\u2117\u2116\u0001\u0000"+ + "\u0000\u0000\u2118\u043d\u0001\u0000\u0000\u0000\u2119\u211a\u0003\u04be"+ + "\u025f\u0000\u211a\u211b\u0003\u0446\u0223\u0000\u211b\u2124\u0001\u0000"+ + "\u0000\u0000\u211c\u211d\u0005\u013b\u0000\u0000\u211d\u211e\u0005B\u0000"+ + "\u0000\u211e\u211f\u0005\u0003\u0000\u0000\u211f\u2120\u0003\u0442\u0221"+ + "\u0000\u2120\u2121\u0005\u0004\u0000\u0000\u2121\u2122\u0003\u0446\u0223"+ + "\u0000\u2122\u2124\u0001\u0000\u0000\u0000\u2123\u2119\u0001\u0000\u0000"+ + "\u0000\u2123\u211c\u0001\u0000\u0000\u0000\u2124\u043f\u0001\u0000\u0000"+ + "\u0000\u2125\u2126\u0003\u04be\u025f\u0000\u2126\u2127\u0003\u0444\u0222"+ + "\u0000\u2127\u0441\u0001\u0000\u0000\u0000\u2128\u212d\u0003\u0440\u0220"+ + "\u0000\u2129\u212a\u0005\u0007\u0000\u0000\u212a\u212c\u0003\u0440\u0220"+ + "\u0000\u212b\u2129\u0001\u0000\u0000\u0000\u212c\u212f\u0001\u0000\u0000"+ + "\u0000\u212d\u212b\u0001\u0000\u0000\u0000\u212d\u212e\u0001\u0000\u0000"+ + "\u0000\u212e\u0443\u0001\u0000\u0000\u0000\u212f\u212d\u0001\u0000\u0000"+ + "\u0000\u2130\u2131\u0005&\u0000\u0000\u2131\u2132\u0005\u0003\u0000\u0000"+ + "\u2132\u2133\u0003\u044e\u0227\u0000\u2133\u2134\u0005\u0004\u0000\u0000"+ + "\u2134\u2137\u0001\u0000\u0000\u0000\u2135\u2137\u0001\u0000\u0000\u0000"+ + "\u2136\u2130\u0001\u0000\u0000\u0000\u2136\u2135\u0001\u0000\u0000\u0000"+ + "\u2137\u0445\u0001\u0000\u0000\u0000\u2138\u2139\u0005k\u0000\u0000\u2139"+ + "\u213c\u0005\u01db\u0000\u0000\u213a\u213c\u0001\u0000\u0000\u0000\u213b"+ + "\u2138\u0001\u0000\u0000\u0000\u213b\u213a\u0001\u0000\u0000\u0000\u213c"+ + "\u0447\u0001\u0000\u0000\u0000\u213d\u213e\u0005i\u0000\u0000\u213e\u2141"+ + "\u0003\u048c\u0246\u0000\u213f\u2141\u0001\u0000\u0000\u0000\u2140\u213d"+ + "\u0001\u0000\u0000\u0000\u2140\u213f\u0001\u0000\u0000\u0000\u2141\u0449"+ + "\u0001\u0000\u0000\u0000\u2142\u2147\u0005i\u0000\u0000\u2143\u2144\u0005"+ + "\u01b4\u0000\u0000\u2144\u2145\u0005\u010e\u0000\u0000\u2145\u2148\u0003"+ + "\u03ba\u01dd\u0000\u2146\u2148\u0003\u048c\u0246\u0000\u2147\u2143\u0001"+ + "\u0000\u0000\u0000\u2147\u2146\u0001\u0000\u0000\u0000\u2148\u214b\u0001"+ + "\u0000\u0000\u0000\u2149\u214b\u0001\u0000\u0000\u0000\u214a\u2142\u0001"+ + "\u0000\u0000\u0000\u214a\u2149\u0001\u0000\u0000\u0000\u214b\u044b\u0001"+ + "\u0000\u0000\u0000\u214c\u214f\u0003\u044e\u0227\u0000\u214d\u214f\u0001"+ + "\u0000\u0000\u0000\u214e\u214c\u0001\u0000\u0000\u0000\u214e\u214d\u0001"+ + "\u0000\u0000\u0000\u214f\u044d\u0001\u0000\u0000\u0000\u2150\u2155\u0003"+ + "\u0450\u0228\u0000\u2151\u2152\u0005\u0007\u0000\u0000\u2152\u2154\u0003"+ + "\u0450\u0228\u0000\u2153\u2151\u0001\u0000\u0000\u0000\u2154\u2157\u0001"+ + "\u0000\u0000\u0000\u2155\u2153\u0001\u0000\u0000\u0000\u2155\u2156\u0001"+ + "\u0000\u0000\u0000\u2156\u044f\u0001\u0000\u0000\u0000\u2157\u2155\u0001"+ + "\u0000\u0000\u0000\u2158\u2159\u0003\u055c\u02ae\u0000\u2159\u215a\u0003"+ + "\u0460\u0230\u0000\u215a\u215b\u0003n7\u0000\u215b\u0451\u0001\u0000\u0000"+ + "\u0000\u215c\u215d\u0005\u01dc\u0000\u0000\u215d\u216d\u0005\u0003\u0000"+ + "\u0000\u215e\u215f\u0003\u04b8\u025c\u0000\u215f\u2160\u0003\u04d0\u0268"+ + "\u0000\u2160\u2161\u0005\u01dd\u0000\u0000\u2161\u2162\u0003\u0454\u022a"+ + "\u0000\u2162\u216e\u0001\u0000\u0000\u0000\u2163\u2164\u0005\u01de\u0000"+ + "\u0000\u2164\u2165\u0005\u0003\u0000\u0000\u2165\u2166\u0003\u045c\u022e"+ + "\u0000\u2166\u2167\u0005\u0004\u0000\u0000\u2167\u2168\u0005\u0007\u0000"+ + "\u0000\u2168\u2169\u0003\u04b8\u025c\u0000\u2169\u216a\u0003\u04d0\u0268"+ + "\u0000\u216a\u216b\u0005\u01dd\u0000\u0000\u216b\u216c\u0003\u0454\u022a"+ + "\u0000\u216c\u216e\u0001\u0000\u0000\u0000\u216d\u215e\u0001\u0000\u0000"+ + "\u0000\u216d\u2163\u0001\u0000\u0000\u0000\u216e\u216f\u0001\u0000\u0000"+ + "\u0000\u216f\u2170\u0005\u0004\u0000\u0000\u2170\u0453\u0001\u0000\u0000"+ + "\u0000\u2171\u2176\u0003\u0456\u022b\u0000\u2172\u2173\u0005\u0007\u0000"+ + "\u0000\u2173\u2175\u0003\u0456\u022b\u0000\u2174\u2172\u0001\u0000\u0000"+ + "\u0000\u2175\u2178\u0001\u0000\u0000\u0000\u2176\u2174\u0001\u0000\u0000"+ + "\u0000\u2176\u2177\u0001\u0000\u0000\u0000\u2177\u0455\u0001\u0000\u0000"+ + "\u0000\u2178\u2176\u0001\u0000\u0000\u0000\u2179\u2180\u0003\u055c\u02ae"+ + "\u0000\u217a\u217c\u0003\u0460\u0230\u0000\u217b\u217d\u0003\u0458\u022c"+ + "\u0000\u217c\u217b\u0001\u0000\u0000\u0000\u217c\u217d\u0001\u0000\u0000"+ + "\u0000\u217d\u2181\u0001\u0000\u0000\u0000\u217e\u217f\u0005@\u0000\u0000"+ + "\u217f\u2181\u0005\u01db\u0000\u0000\u2180\u217a\u0001\u0000\u0000\u0000"+ + "\u2180\u217e\u0001\u0000\u0000\u0000\u2181\u0457\u0001\u0000\u0000\u0000"+ + "\u2182\u2184\u0003\u045a\u022d\u0000\u2183\u2182\u0001\u0000\u0000\u0000"+ + "\u2184\u2185\u0001\u0000\u0000\u0000\u2185\u2183\u0001\u0000\u0000\u0000"+ + "\u2185\u2186\u0001\u0000\u0000\u0000\u2186\u0459\u0001\u0000\u0000\u0000"+ + "\u2187\u2188\u00057\u0000\u0000\u2188\u2190\u0003\u048c\u0246\u0000\u2189"+ + "\u218a\u0003\u0566\u02b3\u0000\u218a\u218b\u0003\u048c\u0246\u0000\u218b"+ + "\u2190\u0001\u0000\u0000\u0000\u218c\u218d\u0005O\u0000\u0000\u218d\u2190"+ + "\u0005P\u0000\u0000\u218e\u2190\u0005P\u0000\u0000\u218f\u2187\u0001\u0000"+ + "\u0000\u0000\u218f\u2189\u0001\u0000\u0000\u0000\u218f\u218c\u0001\u0000"+ + "\u0000\u0000\u218f\u218e\u0001\u0000\u0000\u0000\u2190\u045b\u0001\u0000"+ + "\u0000\u0000\u2191\u2196\u0003\u045e\u022f\u0000\u2192\u2193\u0005\u0007"+ + "\u0000\u0000\u2193\u2195\u0003\u045e\u022f\u0000\u2194\u2192\u0001\u0000"+ + "\u0000\u0000\u2195\u2198\u0001\u0000\u0000\u0000\u2196\u2194\u0001\u0000"+ + "\u0000\u0000\u2196\u2197\u0001\u0000\u0000\u0000\u2197\u045d\u0001\u0000"+ + "\u0000\u0000\u2198\u2196\u0001\u0000\u0000\u0000\u2199\u219a\u0003\u04b6"+ + "\u025b\u0000\u219a\u219b\u0005&\u0000\u0000\u219b\u219c\u0003\u0564\u02b2"+ + "\u0000\u219c\u21a0\u0001\u0000\u0000\u0000\u219d\u219e\u00057\u0000\u0000"+ + "\u219e\u21a0\u0003\u04b6\u025b\u0000\u219f\u2199\u0001\u0000\u0000\u0000"+ + "\u219f\u219d\u0001\u0000\u0000\u0000\u21a0\u045f\u0001\u0000\u0000\u0000"+ + "\u21a1\u21a3\u0005\u019a\u0000\u0000\u21a2\u21a1\u0001\u0000\u0000\u0000"+ + "\u21a2\u21a3\u0001\u0000\u0000\u0000\u21a3\u21a4\u0001\u0000\u0000\u0000"+ + "\u21a4\u21ad\u0003\u0464\u0232\u0000\u21a5\u21ae\u0003\u0462\u0231\u0000"+ + "\u21a6\u21ab\u0005%\u0000\u0000\u21a7\u21a8\u0005\u0005\u0000\u0000\u21a8"+ + "\u21a9\u0003\u054c\u02a6\u0000\u21a9\u21aa\u0005\u0006\u0000\u0000\u21aa"+ + "\u21ac\u0001\u0000\u0000\u0000\u21ab\u21a7\u0001\u0000\u0000\u0000\u21ab"+ + "\u21ac\u0001\u0000\u0000\u0000\u21ac\u21ae\u0001\u0000\u0000\u0000\u21ad"+ + "\u21a5\u0001\u0000\u0000\u0000\u21ad\u21a6\u0001\u0000\u0000\u0000\u21ae"+ + "\u21b4\u0001\u0000\u0000\u0000\u21af\u21b0\u0003\u0538\u029c\u0000\u21b0"+ + "\u21b1\u0005\u001d\u0000\u0000\u21b1\u21b2\u0007*\u0000\u0000\u21b2\u21b4"+ + "\u0001\u0000\u0000\u0000\u21b3\u21a2\u0001\u0000\u0000\u0000\u21b3\u21af"+ + "\u0001\u0000\u0000\u0000\u21b4\u0461\u0001\u0000\u0000\u0000\u21b5\u21b7"+ + "\u0005\u0005\u0000\u0000\u21b6\u21b8\u0003\u054c\u02a6\u0000\u21b7\u21b6"+ + "\u0001\u0000\u0000\u0000\u21b7\u21b8\u0001\u0000\u0000\u0000\u21b8\u21b9"+ + "\u0001\u0000\u0000\u0000\u21b9\u21bb\u0005\u0006\u0000\u0000\u21ba\u21b5"+ + "\u0001\u0000\u0000\u0000\u21bb\u21be\u0001\u0000\u0000\u0000\u21bc\u21ba"+ + "\u0001\u0000\u0000\u0000\u21bc\u21bd\u0001\u0000\u0000\u0000\u21bd\u0463"+ + "\u0001\u0000\u0000\u0000\u21be\u21bc\u0001\u0000\u0000\u0000\u21bf\u21cd"+ + "\u0003\u0468\u0234\u0000\u21c0\u21cd\u0003\u046c\u0236\u0000\u21c1\u21cd"+ + "\u0003\u0470\u0238\u0000\u21c2\u21cd\u0003\u0478\u023c\u0000\u21c3\u21cd"+ + "\u0003\u0480\u0240\u0000\u21c4\u21ca\u0003\u0482\u0241\u0000\u21c5\u21cb"+ + "\u0003\u0486\u0243\u0000\u21c6\u21c7\u0005\u0003\u0000\u0000\u21c7\u21c8"+ + "\u0003\u054c\u02a6\u0000\u21c8\u21c9\u0005\u0004\u0000\u0000\u21c9\u21cb"+ + "\u0001\u0000\u0000\u0000\u21ca\u21c5\u0001\u0000\u0000\u0000\u21ca\u21c6"+ + "\u0001\u0000\u0000\u0000\u21cb\u21cd\u0001\u0000\u0000\u0000\u21cc\u21bf"+ + "\u0001\u0000\u0000\u0000\u21cc\u21c0\u0001\u0000\u0000\u0000\u21cc\u21c1"+ + "\u0001\u0000\u0000\u0000\u21cc\u21c2\u0001\u0000\u0000\u0000\u21cc\u21c3"+ + "\u0001\u0000\u0000\u0000\u21cc\u21c4\u0001\u0000\u0000\u0000\u21cd\u0465"+ + "\u0001\u0000\u0000\u0000\u21ce\u21d3\u0003\u046c\u0236\u0000\u21cf\u21d3"+ + "\u0003\u0472\u0239\u0000\u21d0\u21d3\u0003\u047a\u023d\u0000\u21d1\u21d3"+ + "\u0003\u0480\u0240\u0000\u21d2\u21ce\u0001\u0000\u0000\u0000\u21d2\u21cf"+ + "\u0001\u0000\u0000\u0000\u21d2\u21d0\u0001\u0000\u0000\u0000\u21d2\u21d1"+ + "\u0001\u0000\u0000\u0000\u21d3\u0467\u0001\u0000\u0000\u0000\u21d4\u21d9"+ + "\u0003\u0572\u02b9\u0000\u21d5\u21d9\u0003\u0560\u02b0\u0000\u21d6\u21d9"+ + "\u0005y\u0000\u0000\u21d7\u21d9\u0005\u0080\u0000\u0000\u21d8\u21d4\u0001"+ + "\u0000\u0000\u0000\u21d8\u21d5\u0001\u0000\u0000\u0000\u21d8\u21d6\u0001"+ + "\u0000\u0000\u0000\u21d8\u21d7\u0001\u0000\u0000\u0000\u21d9\u21db\u0001"+ + "\u0000\u0000\u0000\u21da\u21dc\u0003\u020e\u0107\u0000\u21db\u21da\u0001"+ + "\u0000\u0000\u0000\u21db\u21dc\u0001\u0000\u0000\u0000\u21dc\u21dd\u0001"+ + "\u0000\u0000\u0000\u21dd\u21de\u0003\u046a\u0235\u0000\u21de\u0469\u0001"+ + "\u0000\u0000\u0000\u21df\u21e0\u0005\u0003\u0000\u0000\u21e0\u21e1\u0003"+ + "\u0500\u0280\u0000\u21e1\u21e2\u0005\u0004\u0000\u0000\u21e2\u21e5\u0001"+ + "\u0000\u0000\u0000\u21e3\u21e5\u0001\u0000\u0000\u0000\u21e4\u21df\u0001"+ + "\u0000\u0000\u0000\u21e4\u21e3\u0001\u0000\u0000\u0000\u21e5\u046b\u0001"+ + "\u0000\u0000\u0000\u21e6\u21f7\u0005\u018c\u0000\u0000\u21e7\u21f7\u0005"+ + "\u018d\u0000\u0000\u21e8\u21f7\u0005\u019b\u0000\u0000\u21e9\u21f7\u0005"+ + "\u017f\u0000\u0000\u21ea\u21f7\u0005\u0198\u0000\u0000\u21eb\u21ec\u0005"+ + "\u0189\u0000\u0000\u21ec\u21f7\u0003\u046e\u0237\u0000\u21ed\u21ee\u0005"+ + "\u00c0\u0000\u0000\u21ee\u21f7\u0005\u0197\u0000\u0000\u21ef\u21f0\u0005"+ + "\u0186\u0000\u0000\u21f0\u21f7\u0003\u046a\u0235\u0000\u21f1\u21f2\u0005"+ + "\u0185\u0000\u0000\u21f2\u21f7\u0003\u046a\u0235\u0000\u21f3\u21f4\u0005"+ + "\u0194\u0000\u0000\u21f4\u21f7\u0003\u046a\u0235\u0000\u21f5\u21f7\u0005"+ + "\u0181\u0000\u0000\u21f6\u21e6\u0001\u0000\u0000\u0000\u21f6\u21e7\u0001"+ + "\u0000\u0000\u0000\u21f6\u21e8\u0001\u0000\u0000\u0000\u21f6\u21e9\u0001"+ + "\u0000\u0000\u0000\u21f6\u21ea\u0001\u0000\u0000\u0000\u21f6\u21eb\u0001"+ + "\u0000\u0000\u0000\u21f6\u21ed\u0001\u0000\u0000\u0000\u21f6\u21ef\u0001"+ + "\u0000\u0000\u0000\u21f6\u21f1\u0001\u0000\u0000\u0000\u21f6\u21f3\u0001"+ + "\u0000\u0000\u0000\u21f6\u21f5\u0001\u0000\u0000\u0000\u21f7\u046d\u0001"+ + "\u0000\u0000\u0000\u21f8\u21f9\u0005\u0003\u0000\u0000\u21f9\u21fa\u0003"+ + "\u054c\u02a6\u0000\u21fa\u21fb\u0005\u0004\u0000\u0000\u21fb\u21fe\u0001"+ + "\u0000\u0000\u0000\u21fc\u21fe\u0001\u0000\u0000\u0000\u21fd\u21f8\u0001"+ + "\u0000\u0000\u0000\u21fd\u21fc\u0001\u0000\u0000\u0000\u21fe\u046f\u0001"+ + "\u0000\u0000\u0000\u21ff\u2202\u0003\u0474\u023a\u0000\u2200\u2202\u0003"+ + "\u0476\u023b\u0000\u2201\u21ff\u0001\u0000\u0000\u0000\u2201\u2200\u0001"+ + "\u0000\u0000\u0000\u2202\u0471\u0001\u0000\u0000\u0000\u2203\u2206\u0003"+ + "\u0474\u023a\u0000\u2204\u2206\u0003\u0476\u023b\u0000\u2205\u2203\u0001"+ + "\u0000\u0000\u0000\u2205\u2204\u0001\u0000\u0000\u0000\u2206\u0473\u0001"+ + "\u0000\u0000\u0000\u2207\u2208\u0005\u0180\u0000\u0000\u2208\u2209\u0003"+ + "\u047e\u023f\u0000\u2209\u220a\u0005\u0003\u0000\u0000\u220a\u220b\u0003"+ + "\u0500\u0280\u0000\u220b\u220c\u0005\u0004\u0000\u0000\u220c\u0475\u0001"+ + "\u0000\u0000\u0000\u220d\u220e\u0005\u0180\u0000\u0000\u220e\u220f\u0003"+ + "\u047e\u023f\u0000\u220f\u0477\u0001\u0000\u0000\u0000\u2210\u2215\u0003"+ + "\u047c\u023e\u0000\u2211\u2212\u0005\u0003\u0000\u0000\u2212\u2213\u0003"+ + "\u054c\u02a6\u0000\u2213\u2214\u0005\u0004\u0000\u0000\u2214\u2216\u0001"+ + "\u0000\u0000\u0000\u2215\u2211\u0001\u0000\u0000\u0000\u2215\u2216\u0001"+ + "\u0000\u0000\u0000\u2216\u0479\u0001\u0000\u0000\u0000\u2217\u221c\u0003"+ + "\u047c\u023e\u0000\u2218\u2219\u0005\u0003\u0000\u0000\u2219\u221a\u0003"+ + "\u054c\u02a6\u0000\u221a\u221b\u0005\u0004\u0000\u0000\u221b\u221d\u0001"+ + "\u0000\u0000\u0000\u221c\u2218\u0001\u0000\u0000\u0000\u221c\u221d\u0001"+ + "\u0000\u0000\u0000\u221d\u047b\u0001\u0000\u0000\u0000\u221e\u221f\u0007"+ + "+\u0000\u0000\u221f\u2225\u0003\u047e\u023f\u0000\u2220\u2225\u0005\u01a2"+ + "\u0000\u0000\u2221\u2222\u0005\u0190\u0000\u0000\u2222\u2223\u0007,\u0000"+ + "\u0000\u2223\u2225\u0003\u047e\u023f\u0000\u2224\u221e\u0001\u0000\u0000"+ + "\u0000\u2224\u2220\u0001\u0000\u0000\u0000\u2224\u2221\u0001\u0000\u0000"+ + "\u0000\u2225\u047d\u0001\u0000\u0000\u0000\u2226\u2229\u0005\u0171\u0000"+ + "\u0000\u2227\u2229\u0001\u0000\u0000\u0000\u2228\u2226\u0001\u0000\u0000"+ + "\u0000\u2228\u2227\u0001\u0000\u0000\u0000\u2229\u047f\u0001\u0000\u0000"+ + "\u0000\u222a\u222f\u0007-\u0000\u0000\u222b\u222c\u0005\u0003\u0000\u0000"+ + "\u222c\u222d\u0003\u054c\u02a6\u0000\u222d\u222e\u0005\u0004\u0000\u0000"+ + "\u222e\u2230\u0001\u0000\u0000\u0000\u222f\u222b\u0001\u0000\u0000\u0000"+ + "\u222f\u2230\u0001\u0000\u0000\u0000\u2230\u2231\u0001\u0000\u0000\u0000"+ + "\u2231\u2232\u0003\u0484\u0242\u0000\u2232\u0481\u0001\u0000\u0000\u0000"+ + "\u2233\u2234\u0005\u018e\u0000\u0000\u2234\u0483\u0001\u0000\u0000\u0000"+ + "\u2235\u2236\u0005k\u0000\u0000\u2236\u2237\u0005\u019d\u0000\u0000\u2237"+ + "\u223d\u0005\u017d\u0000\u0000\u2238\u2239\u0005\u0176\u0000\u0000\u2239"+ + "\u223a\u0005\u019d\u0000\u0000\u223a\u223d\u0005\u017d\u0000\u0000\u223b"+ + "\u223d\u0001\u0000\u0000\u0000\u223c\u2235\u0001\u0000\u0000\u0000\u223c"+ + "\u2238\u0001\u0000\u0000\u0000\u223c\u223b\u0001\u0000\u0000\u0000\u223d"+ + "\u0485\u0001\u0000\u0000\u0000\u223e\u2259\u0005\u017b\u0000\u0000\u223f"+ + "\u2259\u0005\u0103\u0000\u0000\u2240\u2259\u0005\u00b2\u0000\u0000\u2241"+ + "\u2259\u0005\u00dc\u0000\u0000\u2242\u2259\u0005\u0100\u0000\u0000\u2243"+ + "\u2259\u0003\u0488\u0244\u0000\u2244\u2245\u0005\u017b\u0000\u0000\u2245"+ + "\u2246\u0005`\u0000\u0000\u2246\u2259\u0005\u0103\u0000\u0000\u2247\u2248"+ + "\u0005\u00b2\u0000\u0000\u2248\u224c\u0005`\u0000\u0000\u2249\u224d\u0005"+ + "\u00dc\u0000\u0000\u224a\u224d\u0005\u0100\u0000\u0000\u224b\u224d\u0003"+ + "\u0488\u0244\u0000\u224c\u2249\u0001\u0000\u0000\u0000\u224c\u224a\u0001"+ + "\u0000\u0000\u0000\u224c\u224b\u0001\u0000\u0000\u0000\u224d\u2259\u0001"+ + "\u0000\u0000\u0000\u224e\u224f\u0005\u00dc\u0000\u0000\u224f\u2252\u0005"+ + "`\u0000\u0000\u2250\u2253\u0005\u0100\u0000\u0000\u2251\u2253\u0003\u0488"+ + "\u0244\u0000\u2252\u2250\u0001\u0000\u0000\u0000\u2252\u2251\u0001\u0000"+ + "\u0000\u0000\u2253\u2259\u0001\u0000\u0000\u0000\u2254\u2255\u0005\u0100"+ + "\u0000\u0000\u2255\u2256\u0005`\u0000\u0000\u2256\u2259\u0003\u0488\u0244"+ + "\u0000\u2257\u2259\u0001\u0000\u0000\u0000\u2258\u223e\u0001\u0000\u0000"+ + "\u0000\u2258\u223f\u0001\u0000\u0000\u0000\u2258\u2240\u0001\u0000\u0000"+ + "\u0000\u2258\u2241\u0001\u0000\u0000\u0000\u2258\u2242\u0001\u0000\u0000"+ + "\u0000\u2258\u2243\u0001\u0000\u0000\u0000\u2258\u2244\u0001\u0000\u0000"+ + "\u0000\u2258\u2247\u0001\u0000\u0000\u0000\u2258\u224e\u0001\u0000\u0000"+ + "\u0000\u2258\u2254\u0001\u0000\u0000\u0000\u2258\u2257\u0001\u0000\u0000"+ + "\u0000\u2259\u0487\u0001\u0000\u0000\u0000\u225a\u225f\u0005\u0141\u0000"+ + "\u0000\u225b\u225c\u0005\u0003\u0000\u0000\u225c\u225d\u0003\u054c\u02a6"+ + "\u0000\u225d\u225e\u0005\u0004\u0000\u0000\u225e\u2260\u0001\u0000\u0000"+ + "\u0000\u225f\u225b\u0001\u0000\u0000\u0000\u225f\u2260\u0001\u0000\u0000"+ + "\u0000\u2260\u0489\u0001\u0000\u0000\u0000\u2261\u2262\u0005\u00c7\u0000"+ + "\u0000\u2262\u2265\u0003\u048c\u0246\u0000\u2263\u2265\u0001\u0000\u0000"+ + "\u0000\u2264\u2261\u0001\u0000\u0000\u0000\u2264\u2263\u0001\u0000\u0000"+ + "\u0000\u2265\u048b\u0001\u0000\u0000\u0000\u2266\u2267\u0003\u048e\u0247"+ + "\u0000\u2267\u048d\u0001\u0000\u0000\u0000\u2268\u226a\u0003\u0490\u0248"+ + "\u0000\u2269\u226b\u0003\u04fa\u027d\u0000\u226a\u2269\u0001\u0000\u0000"+ + "\u0000\u226a\u226b\u0001\u0000\u0000\u0000\u226b\u048f\u0001\u0000\u0000"+ + "\u0000\u226c\u2271\u0003\u0492\u0249\u0000\u226d\u226e\u0007.\u0000\u0000"+ + "\u226e\u2270\u0003\u0492\u0249\u0000\u226f\u226d\u0001\u0000\u0000\u0000"+ + "\u2270\u2273\u0001\u0000\u0000\u0000\u2271\u226f\u0001\u0000\u0000\u0000"+ + "\u2271\u2272\u0001\u0000\u0000\u0000\u2272\u0491\u0001\u0000\u0000\u0000"+ + "\u2273\u2271\u0001\u0000\u0000\u0000\u2274\u2279\u0003\u0494\u024a\u0000"+ + "\u2275\u2276\u0005T\u0000\u0000\u2276\u2278\u0003\u0494\u024a\u0000\u2277"+ + "\u2275\u0001\u0000\u0000\u0000\u2278\u227b\u0001\u0000\u0000\u0000\u2279"+ + "\u2277\u0001\u0000\u0000\u0000\u2279\u227a\u0001\u0000\u0000\u0000\u227a"+ + "\u0493\u0001\u0000\u0000\u0000\u227b\u2279\u0001\u0000\u0000\u0000\u227c"+ + "\u2281\u0003\u0496\u024b\u0000\u227d\u227e\u0005#\u0000\u0000\u227e\u2280"+ + "\u0003\u0496\u024b\u0000\u227f\u227d\u0001\u0000\u0000\u0000\u2280\u2283"+ + "\u0001\u0000\u0000\u0000\u2281\u227f\u0001\u0000\u0000\u0000\u2281\u2282"+ + "\u0001\u0000\u0000\u0000\u2282\u0495\u0001\u0000\u0000\u0000\u2283\u2281"+ + "\u0001\u0000\u0000\u0000\u2284\u2290\u0003\u0498\u024c\u0000\u2285\u2287"+ + "\u0005O\u0000\u0000\u2286\u2285\u0001\u0000\u0000\u0000\u2286\u2287\u0001"+ + "\u0000\u0000\u0000\u2287\u2288\u0001\u0000\u0000\u0000\u2288\u228a\u0005"+ + "\u017e\u0000\u0000\u2289\u228b\u0005]\u0000\u0000\u228a\u2289\u0001\u0000"+ + "\u0000\u0000\u228a\u228b\u0001\u0000\u0000\u0000\u228b\u228c\u0001\u0000"+ + "\u0000\u0000\u228c\u228d\u0003\u0498\u024c\u0000\u228d\u228e\u0005#\u0000"+ + "\u0000\u228e\u228f\u0003\u0498\u024c\u0000\u228f\u2291\u0001\u0000\u0000"+ + "\u0000\u2290\u2286\u0001\u0000\u0000\u0000\u2290\u2291\u0001\u0000\u0000"+ + "\u0000\u2291\u0497\u0001\u0000\u0000\u0000\u2292\u2298\u0003\u049a\u024d"+ + "\u0000\u2293\u2295\u0005O\u0000\u0000\u2294\u2293\u0001\u0000\u0000\u0000"+ + "\u2294\u2295\u0001\u0000\u0000\u0000\u2295\u2296\u0001\u0000\u0000\u0000"+ + "\u2296\u2297\u0005F\u0000\u0000\u2297\u2299\u0003\u051a\u028d\u0000\u2298"+ + "\u2294\u0001\u0000\u0000\u0000\u2298\u2299\u0001\u0000\u0000\u0000\u2299"+ + "\u0499\u0001\u0000\u0000\u0000\u229a\u229c\u0005O\u0000\u0000\u229b\u229a"+ + "\u0001\u0000\u0000\u0000\u229b\u229c\u0001\u0000\u0000\u0000\u229c\u229d"+ + "\u0001\u0000\u0000\u0000\u229d\u229e\u0003\u049c\u024e\u0000\u229e\u049b"+ + "\u0001\u0000\u0000\u0000\u229f\u22a1\u0003\u049e\u024f\u0000\u22a0\u22a2"+ + "\u0007/\u0000\u0000\u22a1\u22a0\u0001\u0000\u0000\u0000\u22a1\u22a2\u0001"+ + "\u0000\u0000\u0000\u22a2\u049d\u0001\u0000\u0000\u0000\u22a3\u22bb\u0003"+ + "\u04a0\u0250\u0000\u22a4\u22a6\u0005v\u0000\u0000\u22a5\u22a7\u0005O\u0000"+ + "\u0000\u22a6\u22a5\u0001\u0000\u0000\u0000\u22a6\u22a7\u0001\u0000\u0000"+ + "\u0000\u22a7\u22b9\u0001\u0000\u0000\u0000\u22a8\u22ba\u0005P\u0000\u0000"+ + "\u22a9\u22ba\u0005b\u0000\u0000\u22aa\u22ba\u0005>\u0000\u0000\u22ab\u22ba"+ + "\u0005\u0168\u0000\u0000\u22ac\u22ad\u0005:\u0000\u0000\u22ad\u22ae\u0005"+ + "B\u0000\u0000\u22ae\u22ba\u0003\u048c\u0246\u0000\u22af\u22b0\u0005\u010e"+ + "\u0000\u0000\u22b0\u22b1\u0005\u0003\u0000\u0000\u22b1\u22b2\u0003\u0506"+ + "\u0283\u0000\u22b2\u22b3\u0005\u0004\u0000\u0000\u22b3\u22ba\u0001\u0000"+ + "\u0000\u0000\u22b4\u22ba\u0005\u00be\u0000\u0000\u22b5\u22b7\u0003\u0510"+ + "\u0288\u0000\u22b6\u22b5\u0001\u0000\u0000\u0000\u22b6\u22b7\u0001\u0000"+ + "\u0000\u0000\u22b7\u22b8\u0001\u0000\u0000\u0000\u22b8\u22ba\u0005\u01e0"+ + "\u0000\u0000\u22b9\u22a8\u0001\u0000\u0000\u0000\u22b9\u22a9\u0001\u0000"+ + "\u0000\u0000\u22b9\u22aa\u0001\u0000\u0000\u0000\u22b9\u22ab\u0001\u0000"+ + "\u0000\u0000\u22b9\u22ac\u0001\u0000\u0000\u0000\u22b9\u22af\u0001\u0000"+ + "\u0000\u0000\u22b9\u22b4\u0001\u0000\u0000\u0000\u22b9\u22b6\u0001\u0000"+ + "\u0000\u0000\u22ba\u22bc\u0001\u0000\u0000\u0000\u22bb\u22a4\u0001\u0000"+ + "\u0000\u0000\u22bb\u22bc\u0001\u0000\u0000\u0000\u22bc\u049f\u0001\u0000"+ + "\u0000\u0000\u22bd\u22c9\u0003\u04a2\u0251\u0000\u22be\u22bf\u00070\u0000"+ + "\u0000\u22bf\u22ca\u0003\u04a2\u0251\u0000\u22c0\u22c1\u0003\u04fe\u027f"+ + "\u0000\u22c1\u22c7\u0003\u04f4\u027a\u0000\u22c2\u22c8\u0003\u03c2\u01e1"+ + "\u0000\u22c3\u22c4\u0005\u0003\u0000\u0000\u22c4\u22c5\u0003\u048c\u0246"+ + "\u0000\u22c5\u22c6\u0005\u0004\u0000\u0000\u22c6\u22c8\u0001\u0000\u0000"+ + "\u0000\u22c7\u22c2\u0001\u0000\u0000\u0000\u22c7\u22c3\u0001\u0000\u0000"+ + "\u0000\u22c8\u22ca\u0001\u0000\u0000\u0000\u22c9\u22be\u0001\u0000\u0000"+ + "\u0000\u22c9\u22c0\u0001\u0000\u0000\u0000\u22c9\u22ca\u0001\u0000\u0000"+ + "\u0000\u22ca\u04a1\u0001\u0000\u0000\u0000\u22cb\u22d8\u0003\u04a4\u0252"+ + "\u0000\u22cc\u22ce\u0005O\u0000\u0000\u22cd\u22cc\u0001\u0000\u0000\u0000"+ + "\u22cd\u22ce\u0001\u0000\u0000\u0000\u22ce\u22d3\u0001\u0000\u0000\u0000"+ + "\u22cf\u22d4\u0005z\u0000\u0000\u22d0\u22d4\u0005t\u0000\u0000\u22d1\u22d2"+ + "\u0005\u0081\u0000\u0000\u22d2\u22d4\u0005`\u0000\u0000\u22d3\u22cf\u0001"+ + "\u0000\u0000\u0000\u22d3\u22d0\u0001\u0000\u0000\u0000\u22d3\u22d1\u0001"+ + "\u0000\u0000\u0000\u22d4\u22d5\u0001\u0000\u0000\u0000\u22d5\u22d6\u0003"+ + "\u04a4\u0252\u0000\u22d6\u22d7\u0003\u048a\u0245\u0000\u22d7\u22d9\u0001"+ + "\u0000\u0000\u0000\u22d8\u22cd\u0001\u0000\u0000\u0000\u22d8\u22d9\u0001"+ + "\u0000\u0000\u0000\u22d9\u04a3\u0001\u0000\u0000\u0000\u22da\u22e0\u0003"+ + "\u04a6\u0253\u0000\u22db\u22dc\u0003\u04fa\u027d\u0000\u22dc\u22dd\u0003"+ + "\u04a6\u0253\u0000\u22dd\u22df\u0001\u0000\u0000\u0000\u22de\u22db\u0001"+ + "\u0000\u0000\u0000\u22df\u22e2\u0001\u0000\u0000\u0000\u22e0\u22de\u0001"+ + "\u0000\u0000\u0000\u22e0\u22e1\u0001\u0000\u0000\u0000\u22e1\u04a5\u0001"+ + "\u0000\u0000\u0000\u22e2\u22e0\u0001\u0000\u0000\u0000\u22e3\u22e9\u0003"+ + "\u0658\u032c\u0000\u22e4\u22e6\u0003\u04fa\u027d\u0000\u22e5\u22e4\u0001"+ + "\u0000\u0000\u0000\u22e5\u22e6\u0001\u0000\u0000\u0000\u22e6\u22e7\u0001"+ + "\u0000\u0000\u0000\u22e7\u22e9\u0003\u04a8\u0254\u0000\u22e8\u22e3\u0001"+ + "\u0000\u0000\u0000\u22e8\u22e5\u0001\u0000\u0000\u0000\u22e9\u04a7\u0001"+ + "\u0000\u0000\u0000\u22ea\u22ef\u0003\u04aa\u0255\u0000\u22eb\u22ec\u0007"+ + "1\u0000\u0000\u22ec\u22ee\u0003\u04aa\u0255\u0000\u22ed\u22eb\u0001\u0000"+ + "\u0000\u0000\u22ee\u22f1\u0001\u0000\u0000\u0000\u22ef\u22ed\u0001\u0000"+ + "\u0000\u0000\u22ef\u22f0\u0001\u0000\u0000\u0000\u22f0\u04a9\u0001\u0000"+ + "\u0000\u0000\u22f1\u22ef\u0001\u0000\u0000\u0000\u22f2\u22f7\u0003\u04ac"+ + "\u0256\u0000\u22f3\u22f4\u00072\u0000\u0000\u22f4\u22f6\u0003\u04ac\u0256"+ + "\u0000\u22f5\u22f3\u0001\u0000\u0000\u0000\u22f6\u22f9\u0001\u0000\u0000"+ + "\u0000\u22f7\u22f5\u0001\u0000\u0000\u0000\u22f7\u22f8\u0001\u0000\u0000"+ + "\u0000\u22f8\u04ab\u0001\u0000\u0000\u0000\u22f9\u22f7\u0001\u0000\u0000"+ + "\u0000\u22fa\u22fd\u0003\u04ae\u0257\u0000\u22fb\u22fc\u0005\u0011\u0000"+ + "\u0000\u22fc\u22fe\u0003\u048c\u0246\u0000\u22fd\u22fb\u0001\u0000\u0000"+ + "\u0000\u22fd\u22fe\u0001\u0000\u0000\u0000\u22fe\u04ad\u0001\u0000\u0000"+ + "\u0000\u22ff\u2301\u00071\u0000\u0000\u2300\u22ff\u0001\u0000\u0000\u0000"+ + "\u2300\u2301\u0001\u0000\u0000\u0000\u2301\u2302\u0001\u0000\u0000\u0000"+ + "\u2302\u2303\u0003\u04b0\u0258\u0000\u2303\u04af\u0001\u0000\u0000\u0000"+ + "\u2304\u2309\u0003\u04b2\u0259\u0000\u2305\u2306\u0005\u0090\u0000\u0000"+ + "\u2306\u2307\u0005\u019d\u0000\u0000\u2307\u2308\u0005\u017d\u0000\u0000"+ + "\u2308\u230a\u0003\u048c\u0246\u0000\u2309\u2305\u0001\u0000\u0000\u0000"+ + "\u2309\u230a\u0001\u0000\u0000\u0000\u230a\u04b1\u0001\u0000\u0000\u0000"+ + "\u230b\u230e\u0003\u04b4\u025a\u0000\u230c\u230d\u0005-\u0000\u0000\u230d"+ + "\u230f\u0003\u020c\u0106\u0000\u230e\u230c\u0001\u0000\u0000\u0000\u230e"+ + "\u230f\u0001\u0000\u0000\u0000\u230f\u04b3\u0001\u0000\u0000\u0000\u2310"+ + "\u2315\u0003\u04b8\u025c\u0000\u2311\u2312\u0005\u001c\u0000\u0000\u2312"+ + "\u2314\u0003\u0460\u0230\u0000\u2313\u2311\u0001\u0000\u0000\u0000\u2314"+ + "\u2317\u0001\u0000\u0000\u0000\u2315\u2313\u0001\u0000\u0000\u0000\u2315"+ + "\u2316\u0001\u0000\u0000\u0000\u2316\u04b5\u0001\u0000\u0000\u0000\u2317"+ + "\u2315\u0001\u0000\u0000\u0000\u2318\u2319\u0006\u025b\uffff\uffff\u0000"+ + "\u2319\u2320\u0003\u04b8\u025c\u0000\u231a\u231b\u00071\u0000\u0000\u231b"+ + "\u2320\u0003\u04b6\u025b\t\u231c\u231d\u0003\u04fa\u027d\u0000\u231d\u231e"+ + "\u0003\u04b6\u025b\u0003\u231e\u2320\u0001\u0000\u0000\u0000\u231f\u2318"+ + "\u0001\u0000\u0000\u0000\u231f\u231a\u0001\u0000\u0000\u0000\u231f\u231c"+ + "\u0001\u0000\u0000\u0000\u2320\u2348\u0001\u0000\u0000\u0000\u2321\u2322"+ + "\n\b\u0000\u0000\u2322\u2323\u0005\u0011\u0000\u0000\u2323\u2347\u0003"+ + "\u04b6\u025b\t\u2324\u2325\n\u0007\u0000\u0000\u2325\u2326\u00072\u0000"+ + "\u0000\u2326\u2347\u0003\u04b6\u025b\b\u2327\u2328\n\u0006\u0000\u0000"+ + "\u2328\u2329\u00071\u0000\u0000\u2329\u2347\u0003\u04b6\u025b\u0007\u232a"+ + "\u232b\n\u0005\u0000\u0000\u232b\u232c\u0003\u04fa\u027d\u0000\u232c\u232d"+ + "\u0003\u04b6\u025b\u0006\u232d\u2347\u0001\u0000\u0000\u0000\u232e\u232f"+ + "\n\u0004\u0000\u0000\u232f\u2330\u00070\u0000\u0000\u2330\u2347\u0003"+ + "\u04b6\u025b\u0005\u2331\u2332\n\n\u0000\u0000\u2332\u2333\u0005\u001c"+ + "\u0000\u0000\u2333\u2347\u0003\u0460\u0230\u0000\u2334\u2335\n\u0002\u0000"+ + "\u0000\u2335\u2347\u0003\u04fa\u027d\u0000\u2336\u2337\n\u0001\u0000\u0000"+ + "\u2337\u2339\u0005v\u0000\u0000\u2338\u233a\u0005O\u0000\u0000\u2339\u2338"+ + "\u0001\u0000\u0000\u0000\u2339\u233a\u0001\u0000\u0000\u0000\u233a\u2344"+ + "\u0001\u0000\u0000\u0000\u233b\u233c\u0005:\u0000\u0000\u233c\u233d\u0005"+ + "B\u0000\u0000\u233d\u2345\u0003\u04b6\u025b\u0000\u233e\u233f\u0005\u010e"+ + "\u0000\u0000\u233f\u2340\u0005\u0003\u0000\u0000\u2340\u2341\u0003\u0506"+ + "\u0283\u0000\u2341\u2342\u0005\u0004\u0000\u0000\u2342\u2345\u0001\u0000"+ + "\u0000\u0000\u2343\u2345\u0005\u00be\u0000\u0000\u2344\u233b\u0001\u0000"+ + "\u0000\u0000\u2344\u233e\u0001\u0000\u0000\u0000\u2344\u2343\u0001\u0000"+ + "\u0000\u0000\u2345\u2347\u0001\u0000\u0000\u0000\u2346\u2321\u0001\u0000"+ + "\u0000\u0000\u2346\u2324\u0001\u0000\u0000\u0000\u2346\u2327\u0001\u0000"+ + "\u0000\u0000\u2346\u232a\u0001\u0000\u0000\u0000\u2346\u232e\u0001\u0000"+ + "\u0000\u0000\u2346\u2331\u0001\u0000\u0000\u0000\u2346\u2334\u0001\u0000"+ + "\u0000\u0000\u2346\u2336\u0001\u0000\u0000\u0000\u2347\u234a\u0001\u0000"+ + "\u0000\u0000\u2348\u2346\u0001\u0000\u0000\u0000\u2348\u2349\u0001\u0000"+ + "\u0000\u0000\u2349\u04b7\u0001\u0000\u0000\u0000\u234a\u2348\u0001\u0000"+ + "\u0000\u0000\u234b\u234c\u0005\u0187\u0000\u0000\u234c\u2370\u0003\u03c2"+ + "\u01e1\u0000\u234d\u2350\u0005%\u0000\u0000\u234e\u2351\u0003\u03c2\u01e1"+ + "\u0000\u234f\u2351\u0003\u0508\u0284\u0000\u2350\u234e\u0001\u0000\u0000"+ + "\u0000\u2350\u234f\u0001\u0000\u0000\u0000\u2351\u2370\u0001\u0000\u0000"+ + "\u0000\u2352\u2353\u0005\u001e\u0000\u0000\u2353\u2370\u0003\u052e\u0297"+ + "\u0000\u2354\u2355\u0005\u01d8\u0000\u0000\u2355\u2356\u0005\u0003\u0000"+ + "\u0000\u2356\u2357\u0003\u0500\u0280\u0000\u2357\u2358\u0005\u0004\u0000"+ + "\u0000\u2358\u2370\u0001\u0000\u0000\u0000\u2359\u235a\u0005d\u0000\u0000"+ + "\u235a\u2370\u0003\u03c2\u01e1\u0000\u235b\u2370\u0003\u0658\u032c\u0000"+ + "\u235c\u2370\u0003\u0526\u0293\u0000\u235d\u2370\u0003\u0544\u02a2\u0000"+ + "\u235e\u235f\u0005\u0003\u0000\u0000\u235f\u2360\u0003\u048c\u0246\u0000"+ + "\u2360\u2361\u0005\u0004\u0000\u0000\u2361\u2362\u0003\u052e\u0297\u0000"+ + "\u2362\u2370\u0001\u0000\u0000\u0000\u2363\u2370\u0003\u051c\u028e\u0000"+ + "\u2364\u2370\u0003\u04bc\u025e\u0000\u2365\u2367\u0003\u03c2\u01e1\u0000"+ + "\u2366\u2368\u0003\u052c\u0296\u0000\u2367\u2366\u0001\u0000\u0000\u0000"+ + "\u2367\u2368\u0001\u0000\u0000\u0000\u2368\u2370\u0001\u0000\u0000\u0000"+ + "\u2369\u2370\u0003\u04f0\u0278\u0000\u236a\u2370\u0003\u04f2\u0279\u0000"+ + "\u236b\u236c\u0003\u04ee\u0277\u0000\u236c\u236d\u0005\u007f\u0000\u0000"+ + "\u236d\u236e\u0003\u04ee\u0277\u0000\u236e\u2370\u0001\u0000\u0000\u0000"+ + "\u236f\u234b\u0001\u0000\u0000\u0000\u236f\u234d\u0001\u0000\u0000\u0000"+ + "\u236f\u2352\u0001\u0000\u0000\u0000\u236f\u2354\u0001\u0000\u0000\u0000"+ + "\u236f\u2359\u0001\u0000\u0000\u0000\u236f\u235b\u0001\u0000\u0000\u0000"+ + "\u236f\u235c\u0001\u0000\u0000\u0000\u236f\u235d\u0001\u0000\u0000\u0000"+ + "\u236f\u235e\u0001\u0000\u0000\u0000\u236f\u2363\u0001\u0000\u0000\u0000"+ + "\u236f\u2364\u0001\u0000\u0000\u0000\u236f\u2365\u0001\u0000\u0000\u0000"+ + "\u236f\u2369\u0001\u0000\u0000\u0000\u236f\u236a\u0001\u0000\u0000\u0000"+ + "\u236f\u236b\u0001\u0000\u0000\u0000\u2370\u04b9\u0001\u0000\u0000\u0000"+ + "\u2371\u2372\u0003\u0542\u02a1\u0000\u2372\u2385\u0005\u0003\u0000\u0000"+ + "\u2373\u2377\u0003\u0502\u0281\u0000\u2374\u2375\u0005\u0007\u0000\u0000"+ + "\u2375\u2376\u0005g\u0000\u0000\u2376\u2378\u0003\u0504\u0282\u0000\u2377"+ + "\u2374\u0001\u0000\u0000\u0000\u2377\u2378\u0001\u0000\u0000\u0000\u2378"+ + "\u2379\u0001\u0000\u0000\u0000\u2379\u237a\u0003\u03e6\u01f3\u0000\u237a"+ + "\u2386\u0001\u0000\u0000\u0000\u237b\u237c\u0005g\u0000\u0000\u237c\u237d"+ + "\u0003\u0504\u0282\u0000\u237d\u237e\u0003\u03e6\u01f3\u0000\u237e\u2386"+ + "\u0001\u0000\u0000\u0000\u237f\u2380\u00073\u0000\u0000\u2380\u2381\u0003"+ + "\u0502\u0281\u0000\u2381\u2382\u0003\u03e6\u01f3\u0000\u2382\u2386\u0001"+ + "\u0000\u0000\u0000\u2383\u2386\u0005\u000b\u0000\u0000\u2384\u2386\u0001"+ + "\u0000\u0000\u0000\u2385\u2373\u0001\u0000\u0000\u0000\u2385\u237b\u0001"+ + "\u0000\u0000\u0000\u2385\u237f\u0001\u0000\u0000\u0000\u2385\u2383\u0001"+ + "\u0000\u0000\u0000\u2385\u2384\u0001\u0000\u0000\u0000\u2386\u2387\u0001"+ + "\u0000\u0000\u0000\u2387\u2388\u0005\u0004\u0000\u0000\u2388\u04bb\u0001"+ + "\u0000\u0000\u0000\u2389\u238a\u0003\u04ba\u025d\u0000\u238a\u238b\u0003"+ + "\u04d4\u026a\u0000\u238b\u238c\u0003\u04d6\u026b\u0000\u238c\u238d\u0003"+ + "\u04de\u026f\u0000\u238d\u2390\u0001\u0000\u0000\u0000\u238e\u2390\u0003"+ + "\u04c0\u0260\u0000\u238f\u2389\u0001\u0000\u0000\u0000\u238f\u238e\u0001"+ + "\u0000\u0000\u0000\u2390\u04bd\u0001\u0000\u0000\u0000\u2391\u2394\u0003"+ + "\u04ba\u025d\u0000\u2392\u2394\u0003\u04c0\u0260\u0000\u2393\u2391\u0001"+ + "\u0000\u0000\u0000\u2393\u2392\u0001\u0000\u0000\u0000\u2394\u04bf\u0001"+ + "\u0000\u0000\u0000\u2395\u2396\u0005n\u0000\u0000\u2396\u2397\u0005@\u0000"+ + "\u0000\u2397\u2398\u0005\u0003\u0000\u0000\u2398\u2399\u0003\u048c\u0246"+ + "\u0000\u2399\u239a\u0005\u0004\u0000\u0000\u239a\u2447\u0001\u0000\u0000"+ + "\u0000\u239b\u2447\u00052\u0000\u0000\u239c\u23a1\u00054\u0000\u0000\u239d"+ + "\u239e\u0005\u0003\u0000\u0000\u239e\u239f\u0003\u054c\u02a6\u0000\u239f"+ + "\u23a0\u0005\u0004\u0000\u0000\u23a0\u23a2\u0001\u0000\u0000\u0000\u23a1"+ + "\u239d\u0001\u0000\u0000\u0000\u23a1\u23a2\u0001\u0000\u0000\u0000\u23a2"+ + "\u2447\u0001\u0000\u0000\u0000\u23a3\u23a8\u00055\u0000\u0000\u23a4\u23a5"+ + "\u0005\u0003\u0000\u0000\u23a5\u23a6\u0003\u054c\u02a6\u0000\u23a6\u23a7"+ + "\u0005\u0004\u0000\u0000\u23a7\u23a9\u0001\u0000\u0000\u0000\u23a8\u23a4"+ + "\u0001\u0000\u0000\u0000\u23a8\u23a9\u0001\u0000\u0000\u0000\u23a9\u2447"+ + "\u0001\u0000\u0000\u0000\u23aa\u23af\u0005M\u0000\u0000\u23ab\u23ac\u0005"+ + "\u0003\u0000\u0000\u23ac\u23ad\u0003\u054c\u02a6\u0000\u23ad\u23ae\u0005"+ + "\u0004\u0000\u0000\u23ae\u23b0\u0001\u0000\u0000\u0000\u23af\u23ab\u0001"+ + "\u0000\u0000\u0000\u23af\u23b0\u0001\u0000\u0000\u0000\u23b0\u2447\u0001"+ + "\u0000\u0000\u0000\u23b1\u23b6\u0005N\u0000\u0000\u23b2\u23b3\u0005\u0003"+ + "\u0000\u0000\u23b3\u23b4\u0003\u054c\u02a6\u0000\u23b4\u23b5\u0005\u0004"+ + "\u0000\u0000\u23b5\u23b7\u0001\u0000\u0000\u0000\u23b6\u23b2\u0001\u0000"+ + "\u0000\u0000\u23b6\u23b7\u0001\u0000\u0000\u0000\u23b7\u2447\u0001\u0000"+ + "\u0000\u0000\u23b8\u2447\u00053\u0000\u0000\u23b9\u2447\u00056\u0000\u0000"+ + "\u23ba\u2447\u0005[\u0000\u0000\u23bb\u2447\u0005e\u0000\u0000\u23bc\u2447"+ + "\u00051\u0000\u0000\u23bd\u2447\u0005q\u0000\u0000\u23be\u23bf\u0005+"+ + "\u0000\u0000\u23bf\u23c0\u0005\u0003\u0000\u0000\u23c0\u23c1\u0003\u048c"+ + "\u0246\u0000\u23c1\u23c2\u0005&\u0000\u0000\u23c2\u23c3\u0003\u0460\u0230"+ + "\u0000\u23c3\u23c4\u0005\u0004\u0000\u0000\u23c4\u2447\u0001\u0000\u0000"+ + "\u0000\u23c5\u23c6\u0005\u0188\u0000\u0000\u23c6\u23c7\u0005\u0003\u0000"+ + "\u0000\u23c7\u23c8\u0003\u050c\u0286\u0000\u23c8\u23c9\u0005\u0004\u0000"+ + "\u0000\u23c9\u2447\u0001\u0000\u0000\u0000\u23ca\u23cb\u0005\u01eb\u0000"+ + "\u0000\u23cb\u23cc\u0005\u0003\u0000\u0000\u23cc\u23cf\u0003\u048c\u0246"+ + "\u0000\u23cd\u23ce\u0005\u0007\u0000\u0000\u23ce\u23d0\u0003\u0510\u0288"+ + "\u0000\u23cf\u23cd\u0001\u0000\u0000\u0000\u23cf\u23d0\u0001\u0000\u0000"+ + "\u0000\u23d0\u23d1\u0001\u0000\u0000\u0000\u23d1\u23d2\u0005\u0004\u0000"+ + "\u0000\u23d2\u2447\u0001\u0000\u0000\u0000\u23d3\u23d4\u0005\u0195\u0000"+ + "\u0000\u23d4\u23d5\u0005\u0003\u0000\u0000\u23d5\u23d6\u0003\u0512\u0289"+ + "\u0000\u23d6\u23d7\u0005\u0004\u0000\u0000\u23d7\u2447\u0001\u0000\u0000"+ + "\u0000\u23d8\u23d9\u0005\u0196\u0000\u0000\u23d9\u23da\u0005\u0003\u0000"+ + "\u0000\u23da\u23db\u0003\u0514\u028a\u0000\u23db\u23dc\u0005\u0004\u0000"+ + "\u0000\u23dc\u2447\u0001\u0000\u0000\u0000\u23dd\u23de\u0005\u019c\u0000"+ + "\u0000\u23de\u23df\u0005\u0003\u0000\u0000\u23df\u23e0\u0003\u0516\u028b"+ + "\u0000\u23e0\u23e1\u0005\u0004\u0000\u0000\u23e1\u2447\u0001\u0000\u0000"+ + "\u0000\u23e2\u23e3\u0005\u019f\u0000\u0000\u23e3\u23e4\u0005\u0003\u0000"+ + "\u0000\u23e4\u23e5\u0003\u048c\u0246\u0000\u23e5\u23e6\u0005&\u0000\u0000"+ + "\u23e6\u23e7\u0003\u0460\u0230\u0000\u23e7\u23e8\u0005\u0004\u0000\u0000"+ + "\u23e8\u2447\u0001\u0000\u0000\u0000\u23e9\u23ea\u0005\u01a0\u0000\u0000"+ + "\u23ea\u23ec\u0005\u0003\u0000\u0000\u23eb\u23ed\u00074\u0000\u0000\u23ec"+ + "\u23eb\u0001\u0000\u0000\u0000\u23ec\u23ed\u0001\u0000\u0000\u0000\u23ed"+ + "\u23ee\u0001\u0000\u0000\u0000\u23ee\u23ef\u0003\u0518\u028c\u0000\u23ef"+ + "\u23f0\u0005\u0004\u0000\u0000\u23f0\u2447\u0001\u0000\u0000\u0000\u23f1"+ + "\u23f2\u0005\u0193\u0000\u0000\u23f2\u23f3\u0005\u0003\u0000\u0000\u23f3"+ + "\u23f4\u0003\u048c\u0246\u0000\u23f4\u23f5\u0005\u0007\u0000\u0000\u23f5"+ + "\u23f6\u0003\u048c\u0246\u0000\u23f6\u23f7\u0005\u0004\u0000\u0000\u23f7"+ + "\u2447\u0001\u0000\u0000\u0000\u23f8\u23f9\u0005\u0184\u0000\u0000\u23f9"+ + "\u23fa\u0005\u0003\u0000\u0000\u23fa\u23fb\u0003\u0500\u0280\u0000\u23fb"+ + "\u23fc\u0005\u0004\u0000\u0000\u23fc\u2447\u0001\u0000\u0000\u0000\u23fd"+ + "\u23fe\u0005\u018a\u0000\u0000\u23fe\u23ff\u0005\u0003\u0000\u0000\u23ff"+ + "\u2400\u0003\u0500\u0280\u0000\u2400\u2401\u0005\u0004\u0000\u0000\u2401"+ + "\u2447\u0001\u0000\u0000\u0000\u2402\u2403\u0005\u018f\u0000\u0000\u2403"+ + "\u2404\u0005\u0003\u0000\u0000\u2404\u2405\u0003\u0500\u0280\u0000\u2405"+ + "\u2406\u0005\u0004\u0000\u0000\u2406\u2447\u0001\u0000\u0000\u0000\u2407"+ + "\u2408\u0005\u01ab\u0000\u0000\u2408\u2409\u0005\u0003\u0000\u0000\u2409"+ + "\u240a\u0003\u0500\u0280\u0000\u240a\u240b\u0005\u0004\u0000\u0000\u240b"+ + "\u2447\u0001\u0000\u0000\u0000\u240c\u240d\u0005\u01ac\u0000\u0000\u240d"+ + "\u240e\u0005\u0003\u0000\u0000\u240e\u240f\u0005\u0105\u0000\u0000\u240f"+ + "\u2415\u0003\u0564\u02b2\u0000\u2410\u2413\u0005\u0007\u0000\u0000\u2411"+ + "\u2414\u0003\u04c6\u0263\u0000\u2412\u2414\u0003\u0500\u0280\u0000\u2413"+ + "\u2411\u0001\u0000\u0000\u0000\u2413\u2412\u0001\u0000\u0000\u0000\u2414"+ + "\u2416\u0001\u0000\u0000\u0000\u2415\u2410\u0001\u0000\u0000\u0000\u2415"+ + "\u2416\u0001\u0000\u0000\u0000\u2416\u2417\u0001\u0000\u0000\u0000\u2417"+ + "\u2418\u0005\u0004\u0000\u0000\u2418\u2447\u0001\u0000\u0000\u0000\u2419"+ + "\u241a\u0005\u01ad\u0000\u0000\u241a\u241b\u0005\u0003\u0000\u0000\u241b"+ + "\u241c\u0003\u04b8\u025c\u0000\u241c\u241d\u0003\u04d0\u0268\u0000\u241d"+ + "\u241e\u0005\u0004\u0000\u0000\u241e\u2447\u0001\u0000\u0000\u0000\u241f"+ + "\u2420\u0005\u01ae\u0000\u0000\u2420\u2421\u0005\u0003\u0000\u0000\u2421"+ + "\u2422\u0003\u04c8\u0264\u0000\u2422\u2423\u0005\u0004\u0000\u0000\u2423"+ + "\u2447\u0001\u0000\u0000\u0000\u2424\u2425\u0005\u01af\u0000\u0000\u2425"+ + "\u2426\u0005\u0003\u0000\u0000\u2426\u2427\u0003\u04cc\u0266\u0000\u2427"+ + "\u2428\u0003\u048c\u0246\u0000\u2428\u2429\u0003\u04ce\u0267\u0000\u2429"+ + "\u242a\u0005\u0004\u0000\u0000\u242a\u2447\u0001\u0000\u0000\u0000\u242b"+ + "\u242c\u0005\u01b0\u0000\u0000\u242c\u242d\u0005\u0003\u0000\u0000\u242d"+ + "\u242e\u0005\u0105\u0000\u0000\u242e\u2431\u0003\u0564\u02b2\u0000\u242f"+ + "\u2430\u0005\u0007\u0000\u0000\u2430\u2432\u0003\u048c\u0246\u0000\u2431"+ + "\u242f\u0001\u0000\u0000\u0000\u2431\u2432\u0001\u0000\u0000\u0000\u2432"+ + "\u2433\u0001\u0000\u0000\u0000\u2433\u2434\u0005\u0004\u0000\u0000\u2434"+ + "\u2447\u0001\u0000\u0000\u0000\u2435\u2436\u0005\u01b1\u0000\u0000\u2436"+ + "\u2437\u0005\u0003\u0000\u0000\u2437\u2438\u0005\u017a\u0000\u0000\u2438"+ + "\u2439\u0003\u048c\u0246\u0000\u2439\u243a\u0005\u0007\u0000\u0000\u243a"+ + "\u243b\u0003\u04c2\u0261\u0000\u243b\u243c\u0003\u04c4\u0262\u0000\u243c"+ + "\u243d\u0005\u0004\u0000\u0000\u243d\u2447\u0001\u0000\u0000\u0000\u243e"+ + "\u243f\u0005\u01b2\u0000\u0000\u243f\u2440\u0005\u0003\u0000\u0000\u2440"+ + "\u2441\u0003\u04cc\u0266\u0000\u2441\u2442\u0003\u048c\u0246\u0000\u2442"+ + "\u2443\u0005&\u0000\u0000\u2443\u2444\u0003\u0464\u0232\u0000\u2444\u2445"+ + "\u0005\u0004\u0000\u0000\u2445\u2447\u0001\u0000\u0000\u0000\u2446\u2395"+ + "\u0001\u0000\u0000\u0000\u2446\u239b\u0001\u0000\u0000\u0000\u2446\u239c"+ + "\u0001\u0000\u0000\u0000\u2446\u23a3\u0001\u0000\u0000\u0000\u2446\u23aa"+ + "\u0001\u0000\u0000\u0000\u2446\u23b1\u0001\u0000\u0000\u0000\u2446\u23b8"+ + "\u0001\u0000\u0000\u0000\u2446\u23b9\u0001\u0000\u0000\u0000\u2446\u23ba"+ + "\u0001\u0000\u0000\u0000\u2446\u23bb\u0001\u0000\u0000\u0000\u2446\u23bc"+ + "\u0001\u0000\u0000\u0000\u2446\u23bd\u0001\u0000\u0000\u0000\u2446\u23be"+ + "\u0001\u0000\u0000\u0000\u2446\u23c5\u0001\u0000\u0000\u0000\u2446\u23ca"+ + "\u0001\u0000\u0000\u0000\u2446\u23d3\u0001\u0000\u0000\u0000\u2446\u23d8"+ + "\u0001\u0000\u0000\u0000\u2446\u23dd\u0001\u0000\u0000\u0000\u2446\u23e2"+ + "\u0001\u0000\u0000\u0000\u2446\u23e9\u0001\u0000\u0000\u0000\u2446\u23f1"+ + "\u0001\u0000\u0000\u0000\u2446\u23f8\u0001\u0000\u0000\u0000\u2446\u23fd"+ + "\u0001\u0000\u0000\u0000\u2446\u2402\u0001\u0000\u0000\u0000\u2446\u2407"+ + "\u0001\u0000\u0000\u0000\u2446\u240c\u0001\u0000\u0000\u0000\u2446\u2419"+ + "\u0001\u0000\u0000\u0000\u2446\u241f\u0001\u0000\u0000\u0000\u2446\u2424"+ + "\u0001\u0000\u0000\u0000\u2446\u242b\u0001\u0000\u0000\u0000\u2446\u2435"+ + "\u0001\u0000\u0000\u0000\u2446\u243e\u0001\u0000\u0000\u0000\u2447\u04c1"+ + "\u0001\u0000\u0000\u0000\u2448\u2449\u0005\u0172\u0000\u0000\u2449\u244e"+ + "\u0003\u048c\u0246\u0000\u244a\u244b\u0005\u0172\u0000\u0000\u244b\u244c"+ + "\u0005\u0108\u0000\u0000\u244c\u244e\u0005\u01c4\u0000\u0000\u244d\u2448"+ + "\u0001\u0000\u0000\u0000\u244d\u244a\u0001\u0000\u0000\u0000\u244e\u04c3"+ + "\u0001\u0000\u0000\u0000\u244f\u2450\u0005\u0007\u0000\u0000\u2450\u2451"+ + "\u0005\u014e\u0000\u0000\u2451\u245b\u0005\u017c\u0000\u0000\u2452\u2453"+ + "\u0005\u0007\u0000\u0000\u2453\u2454\u0005\u014e\u0000\u0000\u2454\u245b"+ + "\u0005\u0108\u0000\u0000\u2455\u2456\u0005\u0007\u0000\u0000\u2456\u2457"+ + "\u0005\u014e\u0000\u0000\u2457\u2458\u0005\u0108\u0000\u0000\u2458\u245b"+ + "\u0005\u01c4\u0000\u0000\u2459\u245b\u0001\u0000\u0000\u0000\u245a\u244f"+ + "\u0001\u0000\u0000\u0000\u245a\u2452\u0001\u0000\u0000\u0000\u245a\u2455"+ + "\u0001\u0000\u0000\u0000\u245a\u2459\u0001\u0000\u0000\u0000\u245b\u04c5"+ + "\u0001\u0000\u0000\u0000\u245c\u245d\u0005\u01a3\u0000\u0000\u245d\u245e"+ + "\u0005\u0003\u0000\u0000\u245e\u245f\u0003\u04c8\u0264\u0000\u245f\u2460"+ + "\u0005\u0004\u0000\u0000\u2460\u04c7\u0001\u0000\u0000\u0000\u2461\u2466"+ + "\u0003\u04ca\u0265\u0000\u2462\u2463\u0005\u0007\u0000\u0000\u2463\u2465"+ + "\u0003\u04ca\u0265\u0000\u2464\u2462\u0001\u0000\u0000\u0000\u2465\u2468"+ + "\u0001\u0000\u0000\u0000\u2466\u2464\u0001\u0000\u0000\u0000\u2466\u2467"+ + "\u0001\u0000\u0000\u0000\u2467\u04c9\u0001\u0000\u0000\u0000\u2468\u2466"+ + "\u0001\u0000\u0000\u0000\u2469\u246c\u0003\u048c\u0246\u0000\u246a\u246b"+ + "\u0005&\u0000\u0000\u246b\u246d\u0003\u0564\u02b2\u0000\u246c\u246a\u0001"+ + "\u0000\u0000\u0000\u246c\u246d\u0001\u0000\u0000\u0000\u246d\u04cb\u0001"+ + "\u0000\u0000\u0000\u246e\u246f\u00075\u0000\u0000\u246f\u04cd\u0001\u0000"+ + "\u0000\u0000\u2470\u2471\u0005\u011f\u0000\u0000\u2471\u2476\u0005\u0175"+ + "\u0000\u0000\u2472\u2473\u0005\u0156\u0000\u0000\u2473\u2476\u0005\u0175"+ + "\u0000\u0000\u2474\u2476\u0001\u0000\u0000\u0000\u2475\u2470\u0001\u0000"+ + "\u0000\u0000\u2475\u2472\u0001\u0000\u0000\u0000\u2475\u2474\u0001\u0000"+ + "\u0000\u0000\u2476\u04cf\u0001\u0000\u0000\u0000\u2477\u2478\u0005\u0119"+ + "\u0000\u0000\u2478\u2487\u0003\u04b8\u025c\u0000\u2479\u247a\u0005\u0119"+ + "\u0000\u0000\u247a\u247b\u0003\u04b8\u025c\u0000\u247b\u247c\u0003\u04d2"+ + "\u0269\u0000\u247c\u2487\u0001\u0000\u0000\u0000\u247d\u247e\u0005\u0119"+ + "\u0000\u0000\u247e\u247f\u0003\u04d2\u0269\u0000\u247f\u2480\u0003\u04b8"+ + "\u025c\u0000\u2480\u2487\u0001\u0000\u0000\u0000\u2481\u2482\u0005\u0119"+ + "\u0000\u0000\u2482\u2483\u0003\u04d2\u0269\u0000\u2483\u2484\u0003\u04b8"+ + "\u025c\u0000\u2484\u2485\u0003\u04d2\u0269\u0000\u2485\u2487\u0001\u0000"+ + "\u0000\u0000\u2486\u2477\u0001\u0000\u0000\u0000\u2486\u2479\u0001\u0000"+ + "\u0000\u0000\u2486\u247d\u0001\u0000\u0000\u0000\u2486\u2481\u0001\u0000"+ + "\u0000\u0000\u2487\u04d1\u0001\u0000\u0000\u0000\u2488\u2489\u0005\u0095"+ + "\u0000\u0000\u2489\u248a\u00076\u0000\u0000\u248a\u04d3\u0001\u0000\u0000"+ + "\u0000\u248b\u248c\u0005\u01e1\u0000\u0000\u248c\u248d\u0005D\u0000\u0000"+ + "\u248d\u248e\u0005\u0003\u0000\u0000\u248e\u248f\u0003\u03e8\u01f4\u0000"+ + "\u248f\u2490\u0005\u0004\u0000\u0000\u2490\u2493\u0001\u0000\u0000\u0000"+ + "\u2491\u2493\u0001\u0000\u0000\u0000\u2492\u248b\u0001\u0000\u0000\u0000"+ + "\u2492\u2491\u0001\u0000\u0000\u0000\u2493\u04d5\u0001\u0000\u0000\u0000"+ + "\u2494\u2495\u0005\u01e2\u0000\u0000\u2495\u2496\u0005\u0003\u0000\u0000"+ + "\u2496\u2497\u0005i\u0000\u0000\u2497\u2498\u0003\u048c\u0246\u0000\u2498"+ + "\u2499\u0005\u0004\u0000\u0000\u2499\u249c\u0001\u0000\u0000\u0000\u249a"+ + "\u249c\u0001\u0000\u0000\u0000\u249b\u2494\u0001\u0000\u0000\u0000\u249b"+ + "\u249a\u0001\u0000\u0000\u0000\u249c\u04d7\u0001\u0000\u0000\u0000\u249d"+ + "\u249e\u0005j\u0000\u0000\u249e\u24a1\u0003\u04da\u026d\u0000\u249f\u24a1"+ + "\u0001\u0000\u0000\u0000\u24a0\u249d\u0001\u0000\u0000\u0000\u24a0\u249f"+ + "\u0001\u0000\u0000\u0000\u24a1\u04d9\u0001\u0000\u0000\u0000\u24a2\u24a7"+ + "\u0003\u04dc\u026e\u0000\u24a3\u24a4\u0005\u0007\u0000\u0000\u24a4\u24a6"+ + "\u0003\u04dc\u026e\u0000\u24a5\u24a3\u0001\u0000\u0000\u0000\u24a6\u24a9"+ + "\u0001\u0000\u0000\u0000\u24a7\u24a5\u0001\u0000\u0000\u0000\u24a7\u24a8"+ + "\u0001\u0000\u0000\u0000\u24a8\u04db\u0001\u0000\u0000\u0000\u24a9\u24a7"+ + "\u0001\u0000\u0000\u0000\u24aa\u24ab\u0003\u055c\u02ae\u0000\u24ab\u24ac"+ + "\u0005&\u0000\u0000\u24ac\u24ad\u0003\u04e0\u0270\u0000\u24ad\u04dd\u0001"+ + "\u0000\u0000\u0000\u24ae\u24b1\u0005~\u0000\u0000\u24af\u24b2\u0003\u04e0"+ + "\u0270\u0000\u24b0\u24b2\u0003\u055c\u02ae\u0000\u24b1\u24af\u0001\u0000"+ + "\u0000\u0000\u24b1\u24b0\u0001\u0000\u0000\u0000\u24b2\u24b5\u0001\u0000"+ + "\u0000\u0000\u24b3\u24b5\u0001\u0000\u0000\u0000\u24b4\u24ae\u0001\u0000"+ + "\u0000\u0000\u24b4\u24b3\u0001\u0000\u0000\u0000\u24b5\u04df\u0001\u0000"+ + "\u0000\u0000\u24b6\u24b7\u0005\u0003\u0000\u0000\u24b7\u24b8\u0003\u04e2"+ + "\u0271\u0000\u24b8\u24b9\u0003\u04e4\u0272\u0000\u24b9\u24ba\u0003\u03e6"+ + "\u01f3\u0000\u24ba\u24bb\u0003\u04e6\u0273\u0000\u24bb\u24bc\u0005\u0004"+ + "\u0000\u0000\u24bc\u04e1\u0001\u0000\u0000\u0000\u24bd\u24c0\u0003\u055c"+ + "\u02ae\u0000\u24be\u24c0\u0001\u0000\u0000\u0000\u24bf\u24bd\u0001\u0000"+ + "\u0000\u0000\u24bf\u24be\u0001\u0000\u0000\u0000\u24c0\u04e3\u0001\u0000"+ + "\u0000\u0000\u24c1\u24c2\u0005\u0118\u0000\u0000\u24c2\u24c3\u0005\u0095"+ + "\u0000\u0000\u24c3\u24c6\u0003\u0500\u0280\u0000\u24c4\u24c6\u0001\u0000"+ + "\u0000\u0000\u24c5\u24c1\u0001\u0000\u0000\u0000\u24c5\u24c4\u0001\u0000"+ + "\u0000\u0000\u24c6\u04e5\u0001\u0000\u0000\u0000\u24c7\u24c8\u0005\u0126"+ + "\u0000\u0000\u24c8\u24c9\u0003\u04e8\u0274\u0000\u24c9\u24ca\u0003\u04ec"+ + "\u0276\u0000\u24ca\u24d5\u0001\u0000\u0000\u0000\u24cb\u24cc\u0005\u013b"+ + "\u0000\u0000\u24cc\u24cd\u0003\u04e8\u0274\u0000\u24cd\u24ce\u0003\u04ec"+ + "\u0276\u0000\u24ce\u24d5\u0001\u0000\u0000\u0000\u24cf\u24d0\u0005\u01e3"+ + "\u0000\u0000\u24d0\u24d1\u0003\u04e8\u0274\u0000\u24d1\u24d2\u0003\u04ec"+ + "\u0276\u0000\u24d2\u24d5\u0001\u0000\u0000\u0000\u24d3\u24d5\u0001\u0000"+ + "\u0000\u0000\u24d4\u24c7\u0001\u0000\u0000\u0000\u24d4\u24cb\u0001\u0000"+ + "\u0000\u0000\u24d4\u24cf\u0001\u0000\u0000\u0000\u24d4\u24d3\u0001\u0000"+ + "\u0000\u0000\u24d5\u04e7\u0001\u0000\u0000\u0000\u24d6\u24dd\u0003\u04ea"+ + "\u0275\u0000\u24d7\u24d8\u0005\u017e\u0000\u0000\u24d8\u24d9\u0003\u04ea"+ + "\u0275\u0000\u24d9\u24da\u0005#\u0000\u0000\u24da\u24db\u0003\u04ea\u0275"+ + "\u0000\u24db\u24dd\u0001\u0000\u0000\u0000\u24dc\u24d6\u0001\u0000\u0000"+ + "\u0000\u24dc\u24d7\u0001\u0000\u0000\u0000\u24dd\u04e9\u0001\u0000\u0000"+ + "\u0000\u24de\u24df\u0005\u0165\u0000\u0000\u24df\u24e6\u00077\u0000\u0000"+ + "\u24e0\u24e1\u0005\u01b4\u0000\u0000\u24e1\u24e6\u0005\u0199\u0000\u0000"+ + "\u24e2\u24e3\u0003\u048c\u0246\u0000\u24e3\u24e4\u00077\u0000\u0000\u24e4"+ + "\u24e6\u0001\u0000\u0000\u0000\u24e5\u24de\u0001\u0000\u0000\u0000\u24e5"+ + "\u24e0\u0001\u0000\u0000\u0000\u24e5\u24e2\u0001\u0000\u0000\u0000\u24e6"+ + "\u04eb\u0001\u0000\u0000\u0000\u24e7\u24ee\u0005\u00c9\u0000\u0000\u24e8"+ + "\u24e9\u0005\u01b4\u0000\u0000\u24e9\u24ef\u0005\u0199\u0000\u0000\u24ea"+ + "\u24ef\u0005D\u0000\u0000\u24eb\u24ef\u0005\u01d5\u0000\u0000\u24ec\u24ed"+ + "\u0005\u0108\u0000\u0000\u24ed\u24ef\u0005\u01e4\u0000\u0000\u24ee\u24e8"+ + "\u0001\u0000\u0000\u0000\u24ee\u24ea\u0001\u0000\u0000\u0000\u24ee\u24eb"+ + "\u0001\u0000\u0000\u0000\u24ee\u24ec\u0001\u0000\u0000\u0000\u24ef\u24f2"+ + "\u0001\u0000\u0000\u0000\u24f0\u24f2\u0001\u0000\u0000\u0000\u24f1\u24e7"+ + "\u0001\u0000\u0000\u0000\u24f1\u24f0\u0001\u0000\u0000\u0000\u24f2\u04ed"+ + "\u0001\u0000\u0000\u0000\u24f3\u24f4\u0005\u0199\u0000\u0000\u24f4\u24f6"+ + "\u0005\u0003\u0000\u0000\u24f5\u24f7\u0003\u0500\u0280\u0000\u24f6\u24f5"+ + "\u0001\u0000\u0000\u0000\u24f6\u24f7\u0001\u0000\u0000\u0000\u24f7\u24f8"+ + "\u0001\u0000\u0000\u0000\u24f8\u2500\u0005\u0004\u0000\u0000\u24f9\u24fa"+ + "\u0005\u0003\u0000\u0000\u24fa\u24fb\u0003\u0500\u0280\u0000\u24fb\u24fc"+ + "\u0005\u0007\u0000\u0000\u24fc\u24fd\u0003\u048c\u0246\u0000\u24fd\u24fe"+ + "\u0005\u0004\u0000\u0000\u24fe\u2500\u0001\u0000\u0000\u0000\u24ff\u24f3"+ + "\u0001\u0000\u0000\u0000\u24ff\u24f9\u0001\u0000\u0000\u0000\u2500\u04ef"+ + "\u0001\u0000\u0000\u0000\u2501\u2502\u0005\u0199\u0000\u0000\u2502\u2504"+ + "\u0005\u0003\u0000\u0000\u2503\u2505\u0003\u0500\u0280\u0000\u2504\u2503"+ + "\u0001\u0000\u0000\u0000\u2504\u2505\u0001\u0000\u0000\u0000\u2505\u2506"+ + "\u0001\u0000\u0000\u0000\u2506\u2507\u0005\u0004\u0000\u0000\u2507\u04f1"+ + "\u0001\u0000\u0000\u0000\u2508\u2509\u0005\u0003\u0000\u0000\u2509\u250a"+ + "\u0003\u0500\u0280\u0000\u250a\u250b\u0005\u0007\u0000\u0000\u250b\u250c"+ + "\u0003\u048c\u0246\u0000\u250c\u250d\u0005\u0004\u0000\u0000\u250d\u04f3"+ + "\u0001\u0000\u0000\u0000\u250e\u250f\u00078\u0000\u0000\u250f\u04f5\u0001"+ + "\u0000\u0000\u0000\u2510\u2513\u0005\u001f\u0000\u0000\u2511\u2513\u0003"+ + "\u04f8\u027c\u0000\u2512\u2510\u0001\u0000\u0000\u0000\u2512\u2511\u0001"+ + "\u0000\u0000\u0000\u2513\u04f7\u0001\u0000\u0000\u0000\u2514\u2515\u0007"+ + "9\u0000\u0000\u2515\u04f9\u0001\u0000\u0000\u0000\u2516\u251d\u0005\u001f"+ + "\u0000\u0000\u2517\u2518\u0005\u0111\u0000\u0000\u2518\u2519\u0005\u0003"+ + "\u0000\u0000\u2519\u251a\u0003\u02ac\u0156\u0000\u251a\u251b\u0005\u0004"+ + "\u0000\u0000\u251b\u251d\u0001\u0000\u0000\u0000\u251c\u2516\u0001\u0000"+ + "\u0000\u0000\u251c\u2517\u0001\u0000\u0000\u0000\u251d\u04fb\u0001\u0000"+ + "\u0000\u0000\u251e\u2525\u0003\u04f6\u027b\u0000\u251f\u2520\u0005\u0111"+ + "\u0000\u0000\u2520\u2521\u0005\u0003\u0000\u0000\u2521\u2522\u0003\u02ac"+ + "\u0156\u0000\u2522\u2523\u0005\u0004\u0000\u0000\u2523\u2525\u0001\u0000"+ + "\u0000\u0000\u2524\u251e\u0001\u0000\u0000\u0000\u2524\u251f\u0001\u0000"+ + "\u0000\u0000\u2525\u04fd\u0001\u0000\u0000\u0000\u2526\u2533\u0003\u04f6"+ + "\u027b\u0000\u2527\u2528\u0005\u0111\u0000\u0000\u2528\u2529\u0005\u0003"+ + "\u0000\u0000\u2529\u252a\u0003\u02ac\u0156\u0000\u252a\u252b\u0005\u0004"+ + "\u0000\u0000\u252b\u2533\u0001\u0000\u0000\u0000\u252c\u2533\u0005z\u0000"+ + "\u0000\u252d\u252e\u0005O\u0000\u0000\u252e\u2533\u0005z\u0000\u0000\u252f"+ + "\u2533\u0005t\u0000\u0000\u2530\u2531\u0005O\u0000\u0000\u2531\u2533\u0005"+ + "t\u0000\u0000\u2532\u2526\u0001\u0000\u0000\u0000\u2532\u2527\u0001\u0000"+ + "\u0000\u0000\u2532\u252c\u0001\u0000\u0000\u0000\u2532\u252d\u0001\u0000"+ + "\u0000\u0000\u2532\u252f\u0001\u0000\u0000\u0000\u2532\u2530\u0001\u0000"+ + "\u0000\u0000\u2533\u04ff\u0001\u0000\u0000\u0000\u2534\u2539\u0003\u048c"+ + "\u0246\u0000\u2535\u2536\u0005\u0007\u0000\u0000\u2536\u2538\u0003\u048c"+ + "\u0246\u0000\u2537\u2535\u0001\u0000\u0000\u0000\u2538\u253b\u0001\u0000"+ + "\u0000\u0000\u2539\u2537\u0001\u0000\u0000\u0000\u2539\u253a\u0001\u0000"+ + "\u0000\u0000\u253a\u0501\u0001\u0000\u0000\u0000\u253b\u2539\u0001\u0000"+ + "\u0000\u0000\u253c\u2541\u0003\u0504\u0282\u0000\u253d\u253e\u0005\u0007"+ + "\u0000\u0000\u253e\u2540\u0003\u0504\u0282\u0000\u253f\u253d\u0001\u0000"+ + "\u0000\u0000\u2540\u2543\u0001\u0000\u0000\u0000\u2541\u253f\u0001\u0000"+ + "\u0000\u0000\u2541\u2542\u0001\u0000\u0000\u0000\u2542\u0503\u0001\u0000"+ + "\u0000\u0000\u2543\u2541\u0001\u0000\u0000\u0000\u2544\u254a\u0003\u048c"+ + "\u0246\u0000\u2545\u2546\u0003\u027c\u013e\u0000\u2546\u2547\u0007:\u0000"+ + "\u0000\u2547\u2548\u0003\u048c\u0246\u0000\u2548\u254a\u0001\u0000\u0000"+ + "\u0000\u2549\u2544\u0001\u0000\u0000\u0000\u2549\u2545\u0001\u0000\u0000"+ + "\u0000\u254a\u0505\u0001\u0000\u0000\u0000\u254b\u2550\u0003\u0460\u0230"+ + "\u0000\u254c\u254d\u0005\u0007\u0000\u0000\u254d\u254f\u0003\u0460\u0230"+ + "\u0000\u254e\u254c\u0001\u0000\u0000\u0000\u254f\u2552\u0001\u0000\u0000"+ + "\u0000\u2550\u254e\u0001\u0000\u0000\u0000\u2550\u2551\u0001\u0000\u0000"+ + "\u0000\u2551\u0507\u0001\u0000\u0000\u0000\u2552\u2550\u0001\u0000\u0000"+ + "\u0000\u2553\u2556\u0005\u0005\u0000\u0000\u2554\u2557\u0003\u0500\u0280"+ + "\u0000\u2555\u2557\u0003\u050a\u0285\u0000\u2556\u2554\u0001\u0000\u0000"+ + "\u0000\u2556\u2555\u0001\u0000\u0000\u0000\u2556\u2557\u0001\u0000\u0000"+ + "\u0000\u2557\u2558\u0001\u0000\u0000\u0000\u2558\u2559\u0005\u0006\u0000"+ + "\u0000\u2559\u0509\u0001\u0000\u0000\u0000\u255a\u255f\u0003\u0508\u0284"+ + "\u0000\u255b\u255c\u0005\u0007\u0000\u0000\u255c\u255e\u0003\u0508\u0284"+ + "\u0000\u255d\u255b\u0001\u0000\u0000\u0000\u255e\u2561\u0001\u0000\u0000"+ + "\u0000\u255f\u255d\u0001\u0000\u0000\u0000\u255f\u2560\u0001\u0000\u0000"+ + "\u0000\u2560\u050b\u0001\u0000\u0000\u0000\u2561\u255f\u0001\u0000\u0000"+ + "\u0000\u2562\u2563\u0003\u050e\u0287\u0000\u2563\u2564\u0005B\u0000\u0000"+ + "\u2564\u2565\u0003\u048c\u0246\u0000\u2565\u2568\u0001\u0000\u0000\u0000"+ + "\u2566\u2568\u0001\u0000\u0000\u0000\u2567\u2562\u0001\u0000\u0000\u0000"+ + "\u2567\u2566\u0001\u0000\u0000\u0000\u2568\u050d\u0001\u0000\u0000\u0000"+ + "\u2569\u2572\u0003\u0566\u02b3\u0000\u256a\u2572\u0005\u017b\u0000\u0000"+ + "\u256b\u2572\u0005\u0103\u0000\u0000\u256c\u2572\u0005\u00b2\u0000\u0000"+ + "\u256d\u2572\u0005\u00dc\u0000\u0000\u256e\u2572\u0005\u0100\u0000\u0000"+ + "\u256f\u2572\u0005\u0141\u0000\u0000\u2570\u2572\u0003\u054e\u02a7\u0000"+ + "\u2571\u2569\u0001\u0000\u0000\u0000\u2571\u256a\u0001\u0000\u0000\u0000"+ + "\u2571\u256b\u0001\u0000\u0000\u0000\u2571\u256c\u0001\u0000\u0000\u0000"+ + "\u2571\u256d\u0001\u0000\u0000\u0000\u2571\u256e\u0001\u0000\u0000\u0000"+ + "\u2571\u256f\u0001\u0000\u0000\u0000\u2571\u2570\u0001\u0000\u0000\u0000"+ + "\u2572\u050f\u0001\u0000\u0000\u0000\u2573\u2574\u0007;\u0000\u0000\u2574"+ + "\u0511\u0001\u0000\u0000\u0000\u2575\u2576\u0003\u048c\u0246\u0000\u2576"+ + "\u2577\u0005V\u0000\u0000\u2577\u2578\u0003\u048c\u0246\u0000\u2578\u2579"+ + "\u0005B\u0000\u0000\u2579\u257c\u0003\u048c\u0246\u0000\u257a\u257b\u0005"+ + "@\u0000\u0000\u257b\u257d\u0003\u048c\u0246\u0000\u257c\u257a\u0001\u0000"+ + "\u0000\u0000\u257c\u257d\u0001\u0000\u0000\u0000\u257d\u0513\u0001\u0000"+ + "\u0000\u0000\u257e\u257f\u0003\u04b6\u025b\u0000\u257f\u2580\u0005F\u0000"+ + "\u0000\u2580\u2581\u0003\u04b6\u025b\u0000\u2581\u2584\u0001\u0000\u0000"+ + "\u0000\u2582\u2584\u0001\u0000\u0000\u0000\u2583\u257e\u0001\u0000\u0000"+ + "\u0000\u2583\u2582\u0001\u0000\u0000\u0000\u2584\u0515\u0001\u0000\u0000"+ + "\u0000\u2585\u2586\u0003\u048c\u0246\u0000\u2586\u2587\u0005B\u0000\u0000"+ + "\u2587\u2588\u0003\u048c\u0246\u0000\u2588\u2589\u0005@\u0000\u0000\u2589"+ + "\u258a\u0003\u048c\u0246\u0000\u258a\u25a1\u0001\u0000\u0000\u0000\u258b"+ + "\u258c\u0003\u048c\u0246\u0000\u258c\u258d\u0005@\u0000\u0000\u258d\u258e"+ + "\u0003\u048c\u0246\u0000\u258e\u258f\u0005B\u0000\u0000\u258f\u2590\u0003"+ + "\u048c\u0246\u0000\u2590\u25a1\u0001\u0000\u0000\u0000\u2591\u2592\u0003"+ + "\u048c\u0246\u0000\u2592\u2593\u0005B\u0000\u0000\u2593\u2594\u0003\u048c"+ + "\u0246\u0000\u2594\u25a1\u0001\u0000\u0000\u0000\u2595\u2596\u0003\u048c"+ + "\u0246\u0000\u2596\u2597\u0005@\u0000\u0000\u2597\u2598\u0003\u048c\u0246"+ + "\u0000\u2598\u25a1\u0001\u0000\u0000\u0000\u2599\u259a\u0003\u048c\u0246"+ + "\u0000\u259a\u259b\u0005\u0081\u0000\u0000\u259b\u259c\u0003\u048c\u0246"+ + "\u0000\u259c\u259d\u0005\u00c7\u0000\u0000\u259d\u259e\u0003\u048c\u0246"+ + "\u0000\u259e\u25a1\u0001\u0000\u0000\u0000\u259f\u25a1\u0003\u0500\u0280"+ + "\u0000\u25a0\u2585\u0001\u0000\u0000\u0000\u25a0\u258b\u0001\u0000\u0000"+ + "\u0000\u25a0\u2591\u0001\u0000\u0000\u0000\u25a0\u2595\u0001\u0000\u0000"+ + "\u0000\u25a0\u2599\u0001\u0000\u0000\u0000\u25a0\u259f\u0001\u0000\u0000"+ + "\u0000\u25a1\u0517\u0001\u0000\u0000\u0000\u25a2\u25a3\u0003\u048c\u0246"+ + "\u0000\u25a3\u25a4\u0005B\u0000\u0000\u25a4\u25a5\u0003\u0500\u0280\u0000"+ + "\u25a5\u25aa\u0001\u0000\u0000\u0000\u25a6\u25a7\u0005B\u0000\u0000\u25a7"+ + "\u25aa\u0003\u0500\u0280\u0000\u25a8\u25aa\u0003\u0500\u0280\u0000\u25a9"+ + "\u25a2\u0001\u0000\u0000\u0000\u25a9\u25a6\u0001\u0000\u0000\u0000\u25a9"+ + "\u25a8\u0001\u0000\u0000\u0000\u25aa\u0519\u0001\u0000\u0000\u0000\u25ab"+ + "\u25b1\u0003\u03c2\u01e1\u0000\u25ac\u25ad\u0005\u0003\u0000\u0000\u25ad"+ + "\u25ae\u0003\u0500\u0280\u0000\u25ae\u25af\u0005\u0004\u0000\u0000\u25af"+ + "\u25b1\u0001\u0000\u0000\u0000\u25b0\u25ab\u0001\u0000\u0000\u0000\u25b0"+ + "\u25ac\u0001\u0000\u0000\u0000\u25b1\u051b\u0001\u0000\u0000\u0000\u25b2"+ + "\u25b3\u0005*\u0000\u0000\u25b3\u25b4\u0003\u0524\u0292\u0000\u25b4\u25b5"+ + "\u0003\u051e\u028f\u0000\u25b5\u25b6\u0003\u0522\u0291\u0000\u25b6\u25b7"+ + "\u0005\u01c8\u0000\u0000\u25b7\u051d\u0001\u0000\u0000\u0000\u25b8\u25ba"+ + "\u0003\u0520\u0290\u0000\u25b9\u25b8\u0001\u0000\u0000\u0000\u25ba\u25bb"+ + "\u0001\u0000\u0000\u0000\u25bb\u25b9\u0001\u0000\u0000\u0000\u25bb\u25bc"+ + "\u0001\u0000\u0000\u0000\u25bc\u051f\u0001\u0000\u0000\u0000\u25bd\u25be"+ + "\u0005h\u0000\u0000\u25be\u25bf\u0003\u048c\u0246\u0000\u25bf\u25c0\u0005"+ + "_\u0000\u0000\u25c0\u25c1\u0003\u048c\u0246\u0000\u25c1\u0521\u0001\u0000"+ + "\u0000\u0000\u25c2\u25c3\u0005<\u0000\u0000\u25c3\u25c6\u0003\u048c\u0246"+ + "\u0000\u25c4\u25c6\u0001\u0000\u0000\u0000\u25c5\u25c2\u0001\u0000\u0000"+ + "\u0000\u25c5\u25c4\u0001\u0000\u0000\u0000\u25c6\u0523\u0001\u0000\u0000"+ + "\u0000\u25c7\u25ca\u0003\u048c\u0246\u0000\u25c8\u25ca\u0001\u0000\u0000"+ + "\u0000\u25c9\u25c7\u0001\u0000\u0000\u0000\u25c9\u25c8\u0001\u0000\u0000"+ + "\u0000\u25ca\u0525\u0001\u0000\u0000\u0000\u25cb\u25cd\u0003\u055c\u02ae"+ + "\u0000\u25cc\u25ce\u0003\u052c\u0296\u0000\u25cd\u25cc\u0001\u0000\u0000"+ + "\u0000\u25cd\u25ce\u0001\u0000\u0000\u0000\u25ce\u0527\u0001\u0000\u0000"+ + "\u0000\u25cf\u25d2\u0005\r\u0000\u0000\u25d0\u25d3\u0003\u053e\u029f\u0000"+ + "\u25d1\u25d3\u0005\u000b\u0000\u0000\u25d2\u25d0\u0001\u0000\u0000\u0000"+ + "\u25d2\u25d1\u0001\u0000\u0000\u0000\u25d3\u25df\u0001\u0000\u0000\u0000"+ + "\u25d4\u25da\u0005\u0005\u0000\u0000\u25d5\u25db\u0003\u048c\u0246\u0000"+ + "\u25d6\u25d7\u0003\u052a\u0295\u0000\u25d7\u25d8\u0005\t\u0000\u0000\u25d8"+ + "\u25d9\u0003\u052a\u0295\u0000\u25d9\u25db\u0001\u0000\u0000\u0000\u25da"+ + "\u25d5\u0001\u0000\u0000\u0000\u25da\u25d6\u0001\u0000\u0000\u0000\u25db"+ + "\u25dc\u0001\u0000\u0000\u0000\u25dc\u25dd\u0005\u0006\u0000\u0000\u25dd"+ + "\u25df\u0001\u0000\u0000\u0000\u25de\u25cf\u0001\u0000\u0000\u0000\u25de"+ + "\u25d4\u0001\u0000\u0000\u0000\u25df\u0529\u0001\u0000\u0000\u0000\u25e0"+ + "\u25e3\u0003\u048c\u0246\u0000\u25e1\u25e3\u0001\u0000\u0000\u0000\u25e2"+ + "\u25e0\u0001\u0000\u0000\u0000\u25e2\u25e1\u0001\u0000\u0000\u0000\u25e3"+ + "\u052b\u0001\u0000\u0000\u0000\u25e4\u25e6\u0003\u0528\u0294\u0000\u25e5"+ + "\u25e4\u0001\u0000\u0000\u0000\u25e6\u25e7\u0001\u0000\u0000\u0000\u25e7"+ + "\u25e5\u0001\u0000\u0000\u0000\u25e7\u25e8\u0001\u0000\u0000\u0000\u25e8"+ + "\u052d\u0001\u0000\u0000\u0000\u25e9\u25eb\u0003\u0528\u0294\u0000\u25ea"+ + "\u25e9\u0001\u0000\u0000\u0000\u25eb\u25ee\u0001\u0000\u0000\u0000\u25ec"+ + "\u25ea\u0001\u0000\u0000\u0000\u25ec\u25ed\u0001\u0000\u0000\u0000\u25ed"+ + "\u052f\u0001\u0000\u0000\u0000\u25ee\u25ec\u0001\u0000\u0000\u0000\u25ef"+ + "\u25f2\u0003\u0532\u0299\u0000\u25f0\u25f2\u0001\u0000\u0000\u0000\u25f1"+ + "\u25ef\u0001\u0000\u0000\u0000\u25f1\u25f0\u0001\u0000\u0000\u0000\u25f2"+ + "\u0531\u0001\u0000\u0000\u0000\u25f3\u25f8\u0003\u0534\u029a\u0000\u25f4"+ + "\u25f5\u0005\u0007\u0000\u0000\u25f5\u25f7\u0003\u0534\u029a\u0000\u25f6"+ + "\u25f4\u0001\u0000\u0000\u0000\u25f7\u25fa\u0001\u0000\u0000\u0000\u25f8"+ + "\u25f6\u0001\u0000\u0000\u0000\u25f8\u25f9\u0001\u0000\u0000\u0000\u25f9"+ + "\u0533\u0001\u0000\u0000\u0000\u25fa\u25f8\u0001\u0000\u0000\u0000\u25fb"+ + "\u2600\u0003\u048c\u0246\u0000\u25fc\u25fd\u0005&\u0000\u0000\u25fd\u2601"+ + "\u0003\u0564\u02b2\u0000\u25fe\u2601\u0003\u0566\u02b3\u0000\u25ff\u2601"+ + "\u0001\u0000\u0000\u0000\u2600\u25fc\u0001\u0000\u0000\u0000\u2600\u25fe"+ + "\u0001\u0000\u0000\u0000\u2600\u25ff\u0001\u0000\u0000\u0000\u2601\u2604"+ + "\u0001\u0000\u0000\u0000\u2602\u2604\u0005\u000b\u0000\u0000\u2603\u25fb"+ + "\u0001\u0000\u0000\u0000\u2603\u2602\u0001\u0000\u0000\u0000\u2604\u0535"+ + "\u0001\u0000\u0000\u0000\u2605\u260a\u0003\u0538\u029c\u0000\u2606\u2607"+ + "\u0005\u0007\u0000\u0000\u2607\u2609\u0003\u0538\u029c\u0000\u2608\u2606"+ + "\u0001\u0000\u0000\u0000\u2609\u260c\u0001\u0000\u0000\u0000\u260a\u2608"+ + "\u0001\u0000\u0000\u0000\u260a\u260b\u0001\u0000\u0000\u0000\u260b\u0537"+ + "\u0001\u0000\u0000\u0000\u260c\u260a\u0001\u0000\u0000\u0000\u260d\u260f"+ + "\u0003\u055c\u02ae\u0000\u260e\u2610\u0003\u052c\u0296\u0000\u260f\u260e"+ + "\u0001\u0000\u0000\u0000\u260f\u2610\u0001\u0000\u0000\u0000\u2610\u0539"+ + "\u0001\u0000\u0000\u0000\u2611\u2616\u0003\u053c\u029e\u0000\u2612\u2613"+ + "\u0005\u0007\u0000\u0000\u2613\u2615\u0003\u053c\u029e\u0000\u2614\u2612"+ + "\u0001\u0000\u0000\u0000\u2615\u2618\u0001\u0000\u0000\u0000\u2616\u2614"+ + "\u0001\u0000\u0000\u0000\u2616\u2617\u0001\u0000\u0000\u0000\u2617\u053b"+ + "\u0001\u0000\u0000\u0000\u2618\u2616\u0001\u0000\u0000\u0000\u2619\u261a"+ + "\u0003\u055c\u02ae\u0000\u261a\u053d\u0001\u0000\u0000\u0000\u261b\u261c"+ + "\u0003\u0564\u02b2\u0000\u261c\u053f\u0001\u0000\u0000\u0000\u261d\u261e"+ + "\u0003\u054e\u02a7\u0000\u261e\u0541\u0001\u0000\u0000\u0000\u261f\u2627"+ + "\u0003\u0572\u02b9\u0000\u2620\u2627\u0003\u0560\u02b0\u0000\u2621\u2622"+ + "\u0003\u055c\u02ae\u0000\u2622\u2623\u0003\u052c\u0296\u0000\u2623\u2627"+ + "\u0001\u0000\u0000\u0000\u2624\u2627\u0005y\u0000\u0000\u2625\u2627\u0005"+ + "\u0080\u0000\u0000\u2626\u261f\u0001\u0000\u0000\u0000\u2626\u2620\u0001"+ + "\u0000\u0000\u0000\u2626\u2621\u0001\u0000\u0000\u0000\u2626\u2624\u0001"+ + "\u0000\u0000\u0000\u2626\u2625\u0001\u0000\u0000\u0000\u2627\u0543\u0001"+ + "\u0000\u0000\u0000\u2628\u2649\u0003\u054c\u02a6\u0000\u2629\u2649\u0003"+ + "\u054a\u02a5\u0000\u262a\u2649\u0003\u054e\u02a7\u0000\u262b\u2649\u0003"+ + "\u0548\u02a4\u0000\u262c\u2649\u0003\u0546\u02a3\u0000\u262d\u2635\u0003"+ + "\u0542\u02a1\u0000\u262e\u2636\u0003\u054e\u02a7\u0000\u262f\u2630\u0005"+ + "\u0003\u0000\u0000\u2630\u2631\u0003\u0502\u0281\u0000\u2631\u2632\u0003"+ + "\u03e6\u01f3\u0000\u2632\u2633\u0005\u0004\u0000\u0000\u2633\u2634\u0003"+ + "\u054e\u02a7\u0000\u2634\u2636\u0001\u0000\u0000\u0000\u2635\u262e\u0001"+ + "\u0000\u0000\u0000\u2635\u262f\u0001\u0000\u0000\u0000\u2636\u2649\u0001"+ + "\u0000\u0000\u0000\u2637\u2638\u0003\u0466\u0233\u0000\u2638\u2639\u0003"+ + "\u054e\u02a7\u0000\u2639\u2649\u0001\u0000\u0000\u0000\u263a\u2643\u0003"+ + "\u0482\u0241\u0000\u263b\u263c\u0003\u054e\u02a7\u0000\u263c\u263d\u0003"+ + "\u0486\u0243\u0000\u263d\u2644\u0001\u0000\u0000\u0000\u263e\u263f\u0005"+ + "\u0003\u0000\u0000\u263f\u2640\u0003\u054c\u02a6\u0000\u2640\u2641\u0005"+ + "\u0004\u0000\u0000\u2641\u2642\u0003\u054e\u02a7\u0000\u2642\u2644\u0001"+ + "\u0000\u0000\u0000\u2643\u263b\u0001\u0000\u0000\u0000\u2643\u263e\u0001"+ + "\u0000\u0000\u0000\u2644\u2649\u0001\u0000\u0000\u0000\u2645\u2649\u0005"+ + "b\u0000\u0000\u2646\u2649\u0005>\u0000\u0000\u2647\u2649\u0005P\u0000"+ + "\u0000\u2648\u2628\u0001\u0000\u0000\u0000\u2648\u2629\u0001\u0000\u0000"+ + "\u0000\u2648\u262a\u0001\u0000\u0000\u0000\u2648\u262b\u0001\u0000\u0000"+ + "\u0000\u2648\u262c\u0001\u0000\u0000\u0000\u2648\u262d\u0001\u0000\u0000"+ + "\u0000\u2648\u2637\u0001\u0000\u0000\u0000\u2648\u263a\u0001\u0000\u0000"+ + "\u0000\u2648\u2645\u0001\u0000\u0000\u0000\u2648\u2646\u0001\u0000\u0000"+ + "\u0000\u2648\u2647\u0001\u0000\u0000\u0000\u2649\u0545\u0001\u0000\u0000"+ + "\u0000\u264a\u264b\u0005\u0291\u0000\u0000\u264b\u0547\u0001\u0000\u0000"+ + "\u0000\u264c\u264d\u0005\u028d\u0000\u0000\u264d\u0549\u0001\u0000\u0000"+ + "\u0000\u264e\u264f\u0005\u0297\u0000\u0000\u264f\u054b\u0001\u0000\u0000"+ + "\u0000\u2650\u2651\u0005\u0295\u0000\u0000\u2651\u054d\u0001\u0000\u0000"+ + "\u0000\u2652\u2653\u0003\u0550\u02a8\u0000\u2653\u2654\u0003\u0552\u02a9"+ + "\u0000\u2654\u054f\u0001\u0000\u0000\u0000\u2655\u2661\u0005\u0288\u0000"+ + "\u0000\u2656\u2661\u0005\u028a\u0000\u0000\u2657\u265b\u0005\u028c\u0000"+ + "\u0000\u2658\u265a\u0005\u02a5\u0000\u0000\u2659\u2658\u0001\u0000\u0000"+ + "\u0000\u265a\u265d\u0001\u0000\u0000\u0000\u265b\u2659\u0001\u0000\u0000"+ + "\u0000\u265b\u265c\u0001\u0000\u0000\u0000\u265c\u265e\u0001\u0000\u0000"+ + "\u0000\u265d\u265b\u0001\u0000\u0000\u0000\u265e\u2661\u0005\u02a6\u0000"+ + "\u0000\u265f\u2661\u0005\u02a1\u0000\u0000\u2660\u2655\u0001\u0000\u0000"+ + "\u0000\u2660\u2656\u0001\u0000\u0000\u0000\u2660\u2657\u0001\u0000\u0000"+ + "\u0000\u2660\u265f\u0001\u0000\u0000\u0000\u2661\u0551\u0001\u0000\u0000"+ + "\u0000\u2662\u2663\u0005\u01e9\u0000\u0000\u2663\u2666\u0003\u0550\u02a8"+ + "\u0000\u2664\u2666\u0001\u0000\u0000\u0000\u2665\u2662\u0001\u0000\u0000"+ + "\u0000\u2665\u2664\u0001\u0000\u0000\u0000\u2666\u0553\u0001\u0000\u0000"+ + "\u0000\u2667\u266d\u0003\u054c\u02a6\u0000\u2668\u2669\u0005\u000e\u0000"+ + "\u0000\u2669\u266d\u0003\u054c\u02a6\u0000\u266a\u266b\u0005\u000f\u0000"+ + "\u0000\u266b\u266d\u0003\u054c\u02a6\u0000\u266c\u2667\u0001\u0000\u0000"+ + "\u0000\u266c\u2668\u0001\u0000\u0000\u0000\u266c\u266a\u0001\u0000\u0000"+ + "\u0000\u266d\u0555\u0001\u0000\u0000\u0000\u266e\u266f\u0003\u0558\u02ac"+ + "\u0000\u266f\u0557\u0001\u0000\u0000\u0000\u2670\u2674\u0003\u0562\u02b1"+ + "\u0000\u2671\u2674\u00056\u0000\u0000\u2672\u2674\u0005[\u0000\u0000\u2673"+ + "\u2670\u0001\u0000\u0000\u0000\u2673\u2671\u0001\u0000\u0000\u0000\u2673"+ + "\u2672\u0001\u0000\u0000\u0000\u2674\u0559\u0001\u0000\u0000\u0000\u2675"+ + "\u267a\u0003\u0558\u02ac\u0000\u2676\u2677\u0005\u0007\u0000\u0000\u2677"+ + "\u2679\u0003\u0558\u02ac\u0000\u2678\u2676\u0001\u0000\u0000\u0000\u2679"+ + "\u267c\u0001\u0000\u0000\u0000\u267a\u2678\u0001\u0000\u0000\u0000\u267a"+ + "\u267b\u0001\u0000\u0000\u0000\u267b\u055b\u0001\u0000\u0000\u0000\u267c"+ + "\u267a\u0001\u0000\u0000\u0000\u267d\u2684\u0003\u0566\u02b3\u0000\u267e"+ + "\u2684\u0003\u056a\u02b5\u0000\u267f\u2684\u0003\u056c\u02b6\u0000\u2680"+ + "\u2684\u0003\u0648\u0324\u0000\u2681\u2684\u0005y\u0000\u0000\u2682\u2684"+ + "\u0005\u0080\u0000\u0000\u2683\u267d\u0001\u0000\u0000\u0000\u2683\u267e"+ + "\u0001\u0000\u0000\u0000\u2683\u267f\u0001\u0000\u0000\u0000\u2683\u2680"+ + "\u0001\u0000\u0000\u0000\u2683\u2681\u0001\u0000\u0000\u0000\u2683\u2682"+ + "\u0001\u0000\u0000\u0000\u2684\u055d\u0001\u0000\u0000\u0000\u2685\u268a"+ + "\u0003\u0566\u02b3\u0000\u2686\u268a\u0003\u056a\u02b5\u0000\u2687\u268a"+ + "\u0003\u056c\u02b6\u0000\u2688\u268a\u0003\u0648\u0324\u0000\u2689\u2685"+ + "\u0001\u0000\u0000\u0000\u2689\u2686\u0001\u0000\u0000\u0000\u2689\u2687"+ + "\u0001\u0000\u0000\u0000\u2689\u2688\u0001\u0000\u0000\u0000\u268a\u055f"+ + "\u0001\u0000\u0000\u0000\u268b\u2690\u0003\u0566\u02b3\u0000\u268c\u2690"+ + "\u0003\u056a\u02b5\u0000\u268d\u2690\u0003\u0648\u0324\u0000\u268e\u2690"+ + "\u0003\u056e\u02b7\u0000\u268f\u268b\u0001\u0000\u0000\u0000\u268f\u268c"+ + "\u0001\u0000\u0000\u0000\u268f\u268d\u0001\u0000\u0000\u0000\u268f\u268e"+ + "\u0001\u0000\u0000\u0000\u2690\u0561\u0001\u0000\u0000\u0000\u2691\u2696"+ + "\u0003\u0566\u02b3\u0000\u2692\u2696\u0003\u056a\u02b5\u0000\u2693\u2696"+ + "\u0003\u056c\u02b6\u0000\u2694\u2696\u0003\u056e\u02b7\u0000\u2695\u2691"+ + "\u0001\u0000\u0000\u0000\u2695\u2692\u0001\u0000\u0000\u0000\u2695\u2693"+ + "\u0001\u0000\u0000\u0000\u2695\u2694\u0001\u0000\u0000\u0000\u2696\u0563"+ + "\u0001\u0000\u0000\u0000\u2697\u269e\u0003\u0566\u02b3\u0000\u2698\u269e"+ + "\u0003\u0648\u0324\u0000\u2699\u269e\u0003\u056a\u02b5\u0000\u269a\u269e"+ + "\u0003\u056c\u02b6\u0000\u269b\u269e\u0003\u056e\u02b7\u0000\u269c\u269e"+ + "\u0003\u0570\u02b8\u0000\u269d\u2697\u0001\u0000\u0000\u0000\u269d\u2698"+ + "\u0001\u0000\u0000\u0000\u269d\u2699\u0001\u0000\u0000\u0000\u269d\u269a"+ + "\u0001\u0000\u0000\u0000\u269d\u269b\u0001\u0000\u0000\u0000\u269d\u269c"+ + "\u0001\u0000\u0000\u0000\u269e\u0565\u0001\u0000\u0000\u0000\u269f\u26a0"+ + "\u0005\u027f\u0000\u0000\u26a0\u26a6\u0003\u0552\u02a9\u0000\u26a1\u26a6"+ + "\u0005\u0280\u0000\u0000\u26a2\u26a6\u0005\u0284\u0000\u0000\u26a3\u26a6"+ + "\u0003\u0568\u02b4\u0000\u26a4\u26a6\u0003\u0648\u0324\u0000\u26a5\u269f"+ + "\u0001\u0000\u0000\u0000\u26a5\u26a1\u0001\u0000\u0000\u0000\u26a5\u26a2"+ + "\u0001\u0000\u0000\u0000\u26a5\u26a3\u0001\u0000\u0000\u0000\u26a5\u26a4"+ + "\u0001\u0000\u0000\u0000\u26a6\u0567\u0001\u0000\u0000\u0000\u26a7\u26a8"+ + "\u0005\u0298\u0000\u0000\u26a8\u0569\u0001\u0000\u0000\u0000\u26a9\u26aa"+ + "\u0007<\u0000\u0000\u26aa\u056b\u0001\u0000\u0000\u0000\u26ab\u26e0\u0005"+ + "\u017e\u0000\u0000\u26ac\u26e0\u0005\u017f\u0000\u0000\u26ad\u26e0\u0003"+ + "\u0470\u0238\u0000\u26ae\u26e0\u0005\u0181\u0000\u0000\u26af\u26e0\u0005"+ + "\u0182\u0000\u0000\u26b0\u26e0\u0003\u0478\u023c\u0000\u26b1\u26e0\u0005"+ + "\u0184\u0000\u0000\u26b2\u26e0\u0005\u0185\u0000\u0000\u26b3\u26e0\u0005"+ + "\u0186\u0000\u0000\u26b4\u26e0\u0005\u0187\u0000\u0000\u26b5\u26e0\u0005"+ + "\u0188\u0000\u0000\u26b6\u26e0\u0005\u0189\u0000\u0000\u26b7\u26e0\u0005"+ + "\u018a\u0000\u0000\u26b8\u26e0\u0005\u01d8\u0000\u0000\u26b9\u26e0\u0005"+ + "\u018b\u0000\u0000\u26ba\u26e0\u0005\u018c\u0000\u0000\u26bb\u26e0\u0005"+ + "\u018d\u0000\u0000\u26bc\u26e0\u0005\u018e\u0000\u0000\u26bd\u26e0\u0005"+ + "\u018f\u0000\u0000\u26be\u26e0\u0005\u0190\u0000\u0000\u26bf\u26e0\u0005"+ + "\u0191\u0000\u0000\u26c0\u26e0\u0005\u0192\u0000\u0000\u26c1\u26e0\u0005"+ + "\u01eb\u0000\u0000\u26c2\u26e0\u0005\u0193\u0000\u0000\u26c3\u26e0\u0003"+ + "\u046c\u0236\u0000\u26c4\u26e0\u0005\u01c7\u0000\u0000\u26c5\u26e0\u0005"+ + "\u0195\u0000\u0000\u26c6\u26e0\u0005\u0196\u0000\u0000\u26c7\u26e0\u0005"+ + "\u0197\u0000\u0000\u26c8\u26e0\u0005\u0198\u0000\u0000\u26c9\u26e0\u0005"+ + "\u0199\u0000\u0000\u26ca\u26e0\u0005\u019a\u0000\u0000\u26cb\u26e0\u0005"+ + "\u019b\u0000\u0000\u26cc\u26e0\u0005\u019c\u0000\u0000\u26cd\u26e0\u0005"+ + "\u019d\u0000\u0000\u26ce\u26e0\u0005\u019e\u0000\u0000\u26cf\u26e0\u0005"+ + "\u019f\u0000\u0000\u26d0\u26e0\u0005\u01a0\u0000"; + private static final String _serializedATNSegment4 = + "\u0000\u26d1\u26e0\u0005\u01a1\u0000\u0000\u26d2\u26e0\u0005\u01a2\u0000"+ + "\u0000\u26d3\u26e0\u0005\u01a3\u0000\u0000\u26d4\u26e0\u0005\u01ab\u0000"+ + "\u0000\u26d5\u26e0\u0005\u01ac\u0000\u0000\u26d6\u26e0\u0005\u01ad\u0000"+ + "\u0000\u26d7\u26e0\u0005\u01ae\u0000\u0000\u26d8\u26e0\u0005\u01de\u0000"+ + "\u0000\u26d9\u26e0\u0005\u01af\u0000\u0000\u26da\u26e0\u0005\u01b0\u0000"+ + "\u0000\u26db\u26e0\u0005\u01b1\u0000\u0000\u26dc\u26e0\u0005\u01b2\u0000"+ + "\u0000\u26dd\u26e0\u0005\u01dc\u0000\u0000\u26de\u26e0\u0003\u0572\u02b9"+ + "\u0000\u26df\u26ab\u0001\u0000\u0000\u0000\u26df\u26ac\u0001\u0000\u0000"+ + "\u0000\u26df\u26ad\u0001\u0000\u0000\u0000\u26df\u26ae\u0001\u0000\u0000"+ + "\u0000\u26df\u26af\u0001\u0000\u0000\u0000\u26df\u26b0\u0001\u0000\u0000"+ + "\u0000\u26df\u26b1\u0001\u0000\u0000\u0000\u26df\u26b2\u0001\u0000\u0000"+ + "\u0000\u26df\u26b3\u0001\u0000\u0000\u0000\u26df\u26b4\u0001\u0000\u0000"+ + "\u0000\u26df\u26b5\u0001\u0000\u0000\u0000\u26df\u26b6\u0001\u0000\u0000"+ + "\u0000\u26df\u26b7\u0001\u0000\u0000\u0000\u26df\u26b8\u0001\u0000\u0000"+ + "\u0000\u26df\u26b9\u0001\u0000\u0000\u0000\u26df\u26ba\u0001\u0000\u0000"+ + "\u0000\u26df\u26bb\u0001\u0000\u0000\u0000\u26df\u26bc\u0001\u0000\u0000"+ + "\u0000\u26df\u26bd\u0001\u0000\u0000\u0000\u26df\u26be\u0001\u0000\u0000"+ + "\u0000\u26df\u26bf\u0001\u0000\u0000\u0000\u26df\u26c0\u0001\u0000\u0000"+ + "\u0000\u26df\u26c1\u0001\u0000\u0000\u0000\u26df\u26c2\u0001\u0000\u0000"+ + "\u0000\u26df\u26c3\u0001\u0000\u0000\u0000\u26df\u26c4\u0001\u0000\u0000"+ + "\u0000\u26df\u26c5\u0001\u0000\u0000\u0000\u26df\u26c6\u0001\u0000\u0000"+ + "\u0000\u26df\u26c7\u0001\u0000\u0000\u0000\u26df\u26c8\u0001\u0000\u0000"+ + "\u0000\u26df\u26c9\u0001\u0000\u0000\u0000\u26df\u26ca\u0001\u0000\u0000"+ + "\u0000\u26df\u26cb\u0001\u0000\u0000\u0000\u26df\u26cc\u0001\u0000\u0000"+ + "\u0000\u26df\u26cd\u0001\u0000\u0000\u0000\u26df\u26ce\u0001\u0000\u0000"+ + "\u0000\u26df\u26cf\u0001\u0000\u0000\u0000\u26df\u26d0\u0001\u0000\u0000"+ + "\u0000\u26df\u26d1\u0001\u0000\u0000\u0000\u26df\u26d2\u0001\u0000\u0000"+ + "\u0000\u26df\u26d3\u0001\u0000\u0000\u0000\u26df\u26d4\u0001\u0000\u0000"+ + "\u0000\u26df\u26d5\u0001\u0000\u0000\u0000\u26df\u26d6\u0001\u0000\u0000"+ + "\u0000\u26df\u26d7\u0001\u0000\u0000\u0000\u26df\u26d8\u0001\u0000\u0000"+ + "\u0000\u26df\u26d9\u0001\u0000\u0000\u0000\u26df\u26da\u0001\u0000\u0000"+ + "\u0000\u26df\u26db\u0001\u0000\u0000\u0000\u26df\u26dc\u0001\u0000\u0000"+ + "\u0000\u26df\u26dd\u0001\u0000\u0000\u0000\u26df\u26de\u0001\u0000\u0000"+ + "\u0000\u26e0\u056d\u0001\u0000\u0000\u0000\u26e1\u26e2\u0007=\u0000\u0000"+ + "\u26e2\u056f\u0001\u0000\u0000\u0000\u26e3\u26e4\u0007>\u0000\u0000\u26e4"+ + "\u0571\u0001\u0000\u0000\u0000\u26e5\u26e6\u0007?\u0000\u0000\u26e6\u0573"+ + "\u0001\u0000\u0000\u0000\u26e7\u26e8\u0003\u0576\u02bb\u0000\u26e8\u26e9"+ + "\u0003\u0580\u02c0\u0000\u26e9\u26ea\u0003\u057e\u02bf\u0000\u26ea\u0575"+ + "\u0001\u0000\u0000\u0000\u26eb\u26ed\u0003\u0578\u02bc\u0000\u26ec\u26eb"+ + "\u0001\u0000\u0000\u0000\u26ed\u26f0\u0001\u0000\u0000\u0000\u26ee\u26ec"+ + "\u0001\u0000\u0000\u0000\u26ee\u26ef\u0001\u0000\u0000\u0000\u26ef\u0577"+ + "\u0001\u0000\u0000\u0000\u26f0\u26ee\u0001\u0000\u0000\u0000\u26f1\u26f2"+ + "\u0003\u057a\u02bd\u0000\u26f2\u26f3\u0005\u0112\u0000\u0000\u26f3\u26f4"+ + "\u0005\u01ec\u0000\u0000\u26f4\u2706\u0001\u0000\u0000\u0000\u26f5\u26f6"+ + "\u0003\u057a\u02bd\u0000\u26f6\u26f7\u0005\u01ed\u0000\u0000\u26f7\u26f8"+ + "\u0003\u057c\u02be\u0000\u26f8\u2706\u0001\u0000\u0000\u0000\u26f9\u26fa"+ + "\u0003\u057a\u02bd\u0000\u26fa\u26fb\u0005\u01ee\u0000\u0000\u26fb\u26fc"+ + "\u0005\u01ef\u0000\u0000\u26fc\u2706\u0001\u0000\u0000\u0000\u26fd\u26fe"+ + "\u0003\u057a\u02bd\u0000\u26fe\u26ff\u0005\u01ee\u0000\u0000\u26ff\u2700"+ + "\u0005\u01f0\u0000\u0000\u2700\u2706\u0001\u0000\u0000\u0000\u2701\u2702"+ + "\u0003\u057a\u02bd\u0000\u2702\u2703\u0005\u01ee\u0000\u0000\u2703\u2704"+ + "\u0005\u01f1\u0000\u0000\u2704\u2706\u0001\u0000\u0000\u0000\u2705\u26f1"+ + "\u0001\u0000\u0000\u0000\u2705\u26f5\u0001\u0000\u0000\u0000\u2705\u26f9"+ + "\u0001\u0000\u0000\u0000\u2705\u26fd\u0001\u0000\u0000\u0000\u2705\u2701"+ + "\u0001\u0000\u0000\u0000\u2706\u0579\u0001\u0000\u0000\u0000\u2707\u2708"+ + "\u0005\u001f\u0000\u0000\u2708\u057b\u0001\u0000\u0000\u0000\u2709\u270e"+ + "\u0003\u054e\u02a7\u0000\u270a\u270e\u0003\u0570\u02b8\u0000\u270b\u270e"+ + "\u0003\u0648\u0324\u0000\u270c\u270e\u0003\u056a\u02b5\u0000\u270d\u2709"+ + "\u0001\u0000\u0000\u0000\u270d\u270a\u0001\u0000\u0000\u0000\u270d\u270b"+ + "\u0001\u0000\u0000\u0000\u270d\u270c\u0001\u0000\u0000\u0000\u270e\u057d"+ + "\u0001\u0000\u0000\u0000\u270f\u2712\u0001\u0000\u0000\u0000\u2710\u2712"+ + "\u0005\b\u0000\u0000\u2711\u270f\u0001\u0000\u0000\u0000\u2711\u2710\u0001"+ + "\u0000\u0000\u0000\u2712\u057f\u0001\u0000\u0000\u0000\u2713\u2714\u0003"+ + "\u0582\u02c1\u0000\u2714\u2715\u0005\u0094\u0000\u0000\u2715\u2716\u0003"+ + "\u05ac\u02d6\u0000\u2716\u2717\u0003\u0634\u031a\u0000\u2717\u2718\u0005"+ + "\u01c8\u0000\u0000\u2718\u2719\u0003\u0642\u0321\u0000\u2719\u0581\u0001"+ + "\u0000\u0000\u0000\u271a\u271f\u0003\u063e\u031f\u0000\u271b\u271d\u0003"+ + "\u0584\u02c2\u0000\u271c\u271e\u0003\u0586\u02c3\u0000\u271d\u271c\u0001"+ + "\u0000\u0000\u0000\u271d\u271e\u0001\u0000\u0000\u0000\u271e\u2720\u0001"+ + "\u0000\u0000\u0000\u271f\u271b\u0001\u0000\u0000\u0000\u271f\u2720\u0001"+ + "\u0000\u0000\u0000\u2720\u0583\u0001\u0000\u0000\u0000\u2721\u2722\u0005"+ + "\u00b4\u0000\u0000\u2722\u0585\u0001\u0000\u0000\u0000\u2723\u2725\u0003"+ + "\u058a\u02c5\u0000\u2724\u2723\u0001\u0000\u0000\u0000\u2725\u2726\u0001"+ + "\u0000\u0000\u0000\u2726\u2724\u0001\u0000\u0000\u0000\u2726\u2727\u0001"+ + "\u0000\u0000\u0000\u2727\u0587\u0001\u0000\u0000\u0000\u2728\u2729\u0005"+ + "\u0014\u0000\u0000\u2729\u272a\u0003\u0646\u0323\u0000\u272a\u272b\u0005"+ + "\u0015\u0000\u0000\u272b\u0589\u0001\u0000\u0000\u0000\u272c\u2730\u0003"+ + "\u058c\u02c6\u0000\u272d\u2730\u0005\u00b4\u0000\u0000\u272e\u2730\u0003"+ + "\u0588\u02c4\u0000\u272f\u272c\u0001\u0000\u0000\u0000\u272f\u272d\u0001"+ + "\u0000\u0000\u0000\u272f\u272e\u0001\u0000\u0000\u0000\u2730\u058b\u0001"+ + "\u0000\u0000\u0000\u2731\u2741\u0003\u059c\u02ce\u0000\u2732\u2733\u0005"+ + "\u01f2\u0000\u0000\u2733\u2734\u0005@\u0000\u0000\u2734\u2742\u0003\u059a"+ + "\u02cd\u0000\u2735\u2736\u0003\u059e\u02cf\u0000\u2736\u2737\u0003\u05a0"+ + "\u02d0\u0000\u2737\u2738\u0003\u05a2\u02d1\u0000\u2738\u2739\u0003\u05a4"+ + "\u02d2\u0000\u2739\u273a\u0003\u05a6\u02d3\u0000\u273a\u2742\u0001\u0000"+ + "\u0000\u0000\u273b\u273c\u0003\u058e\u02c7\u0000\u273c\u273d\u0005\u00ae"+ + "\u0000\u0000\u273d\u273e\u0003\u0592\u02c9\u0000\u273e\u273f\u0003\u0598"+ + "\u02cc\u0000\u273f\u2740\u0003\u0590\u02c8\u0000\u2740\u2742\u0001\u0000"+ + "\u0000\u0000\u2741\u2732\u0001\u0000\u0000\u0000\u2741\u2735\u0001\u0000"+ + "\u0000\u0000\u2741\u273b\u0001\u0000\u0000\u0000\u2742\u2743\u0001\u0000"+ + "\u0000\u0000\u2743\u2744\u0005\b\u0000\u0000\u2744\u058d\u0001\u0000\u0000"+ + "\u0000\u2745\u274a\u0001\u0000\u0000\u0000\u2746\u2747\u0005\u0108\u0000"+ + "\u0000\u2747\u274a\u0005\u013f\u0000\u0000\u2748\u274a\u0005\u013f\u0000"+ + "\u0000\u2749\u2745\u0001\u0000\u0000\u0000\u2749\u2746\u0001\u0000\u0000"+ + "\u0000\u2749\u2748\u0001\u0000\u0000\u0000\u274a\u058f\u0001\u0000\u0000"+ + "\u0000\u274b\u274c\u0003\u03c0\u01e0\u0000\u274c\u0591\u0001\u0000\u0000"+ + "\u0000\u274d\u2753\u0001\u0000\u0000\u0000\u274e\u274f\u0005\u0003\u0000"+ + "\u0000\u274f\u2750\u0003\u0594\u02ca\u0000\u2750\u2751\u0005\u0004\u0000"+ + "\u0000\u2751\u2753\u0001\u0000\u0000\u0000\u2752\u274d\u0001\u0000\u0000"+ + "\u0000\u2752\u274e\u0001\u0000\u0000\u0000\u2753\u0593\u0001\u0000\u0000"+ + "\u0000\u2754\u2759\u0003\u0596\u02cb\u0000\u2755\u2756\u0005\u0007\u0000"+ + "\u0000\u2756\u2758\u0003\u0596\u02cb\u0000\u2757\u2755\u0001\u0000\u0000"+ + "\u0000\u2758\u275b\u0001\u0000\u0000\u0000\u2759\u2757\u0001\u0000\u0000"+ + "\u0000\u2759\u275a\u0001\u0000\u0000\u0000\u275a\u0595\u0001\u0000\u0000"+ + "\u0000\u275b\u2759\u0001\u0000\u0000\u0000\u275c\u275d\u0003\u059c\u02ce"+ + "\u0000\u275d\u275e\u0003\u05a0\u02d0\u0000\u275e\u0597\u0001\u0000\u0000"+ + "\u0000\u275f\u2760\u0007@\u0000\u0000\u2760\u0599\u0001\u0000\u0000\u0000"+ + "\u2761\u2764\u0005\u001e\u0000\u0000\u2762\u2764\u0003\u055c\u02ae\u0000"+ + "\u2763\u2761\u0001\u0000\u0000\u0000\u2763\u2762\u0001\u0000\u0000\u0000"+ + "\u2764\u059b\u0001\u0000\u0000\u0000\u2765\u2766\u0003\u0646\u0323\u0000"+ + "\u2766\u059d\u0001\u0000\u0000\u0000\u2767\u276a\u0001\u0000\u0000\u0000"+ + "\u2768\u276a\u0005\u01f3\u0000\u0000\u2769\u2767\u0001\u0000\u0000\u0000"+ + "\u2769\u2768\u0001\u0000\u0000\u0000\u276a\u059f\u0001\u0000\u0000\u0000"+ + "\u276b\u276c\u0003\u0460\u0230\u0000\u276c\u05a1\u0001\u0000\u0000\u0000"+ + "\u276d\u2771\u0001\u0000\u0000\u0000\u276e\u276f\u0005-\u0000\u0000\u276f"+ + "\u2771\u0003\u020c\u0106\u0000\u2770\u276d\u0001\u0000\u0000\u0000\u2770"+ + "\u276e\u0001\u0000\u0000\u0000\u2771\u05a3\u0001\u0000\u0000\u0000\u2772"+ + "\u2776\u0001\u0000\u0000\u0000\u2773\u2774\u0005O\u0000\u0000\u2774\u2776"+ + "\u0005P\u0000\u0000\u2775\u2772\u0001\u0000\u0000\u0000\u2775\u2773\u0001"+ + "\u0000\u0000\u0000\u2776\u05a5\u0001\u0000\u0000\u0000\u2777\u277c\u0001"+ + "\u0000\u0000\u0000\u2778\u2779\u0003\u05a8\u02d4\u0000\u2779\u277a\u0003"+ + "\u064a\u0325\u0000\u277a\u277c\u0001\u0000\u0000\u0000\u277b\u2777\u0001"+ + "\u0000\u0000\u0000\u277b\u2778\u0001\u0000\u0000\u0000\u277c\u05a7\u0001"+ + "\u0000\u0000\u0000\u277d\u2780\u0003\u05aa\u02d5\u0000\u277e\u2780\u0005"+ + "7\u0000\u0000\u277f\u277d\u0001\u0000\u0000\u0000\u277f\u277e\u0001\u0000"+ + "\u0000\u0000\u2780\u05a9\u0001\u0000\u0000\u0000\u2781\u2782\u0007A\u0000"+ + "\u0000\u2782\u05ab\u0001\u0000\u0000\u0000\u2783\u2785\u0003\u05ae\u02d7"+ + "\u0000\u2784\u2783\u0001\u0000\u0000\u0000\u2785\u2788\u0001\u0000\u0000"+ + "\u0000\u2786\u2784\u0001\u0000\u0000\u0000\u2786\u2787\u0001\u0000\u0000"+ + "\u0000\u2787\u05ad\u0001\u0000\u0000\u0000\u2788\u2786\u0001\u0000\u0000"+ + "\u0000\u2789\u278a\u0003\u0580\u02c0\u0000\u278a\u278b\u0005\b\u0000\u0000"+ + "\u278b\u27a5\u0001\u0000\u0000\u0000\u278c\u27a5\u0003\u05f0\u02f8\u0000"+ + "\u278d\u27a5\u0003\u05f4\u02fa\u0000\u278e\u27a5\u0003\u05b6\u02db\u0000"+ + "\u278f\u27a5\u0003\u05c6\u02e3\u0000\u2790\u27a5\u0003\u05cc\u02e6\u0000"+ + "\u2791\u27a5\u0003\u05d6\u02eb\u0000\u2792\u27a5\u0003\u05d8\u02ec\u0000"+ + "\u2793\u27a5\u0003\u05da\u02ed\u0000\u2794\u27a5\u0003\u05e8\u02f4\u0000"+ + "\u2795\u27a5\u0003\u05ec\u02f6\u0000\u2796\u27a5\u0003\u0600\u0300\u0000"+ + "\u2797\u27a5\u0003\u0606\u0303\u0000\u2798\u27a5\u0003\u0608\u0304\u0000"+ + "\u2799\u27a5\u0003\u05b0\u02d8\u0000\u279a\u27a5\u0003\u05b2\u02d9\u0000"+ + "\u279b\u27a5\u0003\u05b8\u02dc\u0000\u279c\u27a5\u0003\u0610\u0308\u0000"+ + "\u279d\u27a5\u0003\u061c\u030e\u0000\u279e\u27a5\u0003\u0624\u0312\u0000"+ + "\u279f\u27a5\u0003\u0626\u0313\u0000\u27a0\u27a5\u0003\u0628\u0314\u0000"+ + "\u27a1\u27a5\u0003\u062a\u0315\u0000\u27a2\u27a5\u0003\u062c\u0316\u0000"+ + "\u27a3\u27a5\u0003\u0630\u0318\u0000\u27a4\u2789\u0001\u0000\u0000\u0000"+ + "\u27a4\u278c\u0001\u0000\u0000\u0000\u27a4\u278d\u0001\u0000\u0000\u0000"+ + "\u27a4\u278e\u0001\u0000\u0000\u0000\u27a4\u278f\u0001\u0000\u0000\u0000"+ + "\u27a4\u2790\u0001\u0000\u0000\u0000\u27a4\u2791\u0001\u0000\u0000\u0000"+ + "\u27a4\u2792\u0001\u0000\u0000\u0000\u27a4\u2793\u0001\u0000\u0000\u0000"+ + "\u27a4\u2794\u0001\u0000\u0000\u0000\u27a4\u2795\u0001\u0000\u0000\u0000"+ + "\u27a4\u2796\u0001\u0000\u0000\u0000\u27a4\u2797\u0001\u0000\u0000\u0000"+ + "\u27a4\u2798\u0001\u0000\u0000\u0000\u27a4\u2799\u0001\u0000\u0000\u0000"+ + "\u27a4\u279a\u0001\u0000\u0000\u0000\u27a4\u279b\u0001\u0000\u0000\u0000"+ + "\u27a4\u279c\u0001\u0000\u0000\u0000\u27a4\u279d\u0001\u0000\u0000\u0000"+ + "\u27a4\u279e\u0001\u0000\u0000\u0000\u27a4\u279f\u0001\u0000\u0000\u0000"+ + "\u27a4\u27a0\u0001\u0000\u0000\u0000\u27a4\u27a1\u0001\u0000\u0000\u0000"+ + "\u27a4\u27a2\u0001\u0000\u0000\u0000\u27a4\u27a3\u0001\u0000\u0000\u0000"+ + "\u27a5\u05af\u0001\u0000\u0000\u0000\u27a6\u27a7\u0005\u01f4\u0000\u0000"+ + "\u27a7\u27a8\u0003\u064e\u0327\u0000\u27a8\u27a9\u0005\b\u0000\u0000\u27a9"+ + "\u05b1\u0001\u0000\u0000\u0000\u27aa\u27ab\u0005\u01b3\u0000\u0000\u27ab"+ + "\u27ac\u0003\u0646\u0323\u0000\u27ac\u27ad\u0005\u0003\u0000\u0000\u27ad"+ + "\u27ae\u0003\u05b4\u02da\u0000\u27ae\u27af\u0005\u0004\u0000\u0000\u27af"+ + "\u27b0\u0005\b\u0000\u0000\u27b0\u27b9\u0001\u0000\u0000\u0000\u27b1\u27b2"+ + "\u0005;\u0000\u0000\u27b2\u27b3\u0003\u0646\u0323\u0000\u27b3\u27b4\u0005"+ + "\u0003\u0000\u0000\u27b4\u27b5\u0003\u05b4\u02da\u0000\u27b5\u27b6\u0005"+ + "\u0004\u0000\u0000\u27b6\u27b7\u0005\b\u0000\u0000\u27b7\u27b9\u0001\u0000"+ + "\u0000\u0000\u27b8\u27aa\u0001\u0000\u0000\u0000\u27b8\u27b1\u0001\u0000"+ + "\u0000\u0000\u27b9\u05b3\u0001\u0000\u0000\u0000\u27ba\u27bd\u0001\u0000"+ + "\u0000\u0000\u27bb\u27bd\u0003\u0500\u0280\u0000\u27bc\u27ba\u0001\u0000"+ + "\u0000\u0000\u27bc\u27bb\u0001\u0000\u0000\u0000\u27bd\u05b5\u0001\u0000"+ + "\u0000\u0000\u27be\u27bf\u0003\u05c4\u02e2\u0000\u27bf\u27c0\u0003\u05aa"+ + "\u02d5\u0000\u27c0\u27c1\u0003\u064a\u0325\u0000\u27c1\u27c2\u0005\b\u0000"+ + "\u0000\u27c2\u05b7\u0001\u0000\u0000\u0000\u27c3\u27c4\u0005\u01f5\u0000"+ + "\u0000\u27c4\u27c5\u0003\u05ba\u02dd\u0000\u27c5\u27c6\u0005\u01f6\u0000"+ + "\u0000\u27c6\u27c7\u0003\u05bc\u02de\u0000\u27c7\u27c8\u0005\b\u0000\u0000"+ + "\u27c8\u05b9\u0001\u0000\u0000\u0000\u27c9\u27cd\u0001\u0000\u0000\u0000"+ + "\u27ca\u27cd\u0005\u01b4\u0000\u0000\u27cb\u27cd\u0005\u01f7\u0000\u0000"+ + "\u27cc\u27c9\u0001\u0000\u0000\u0000\u27cc\u27ca\u0001\u0000\u0000\u0000"+ + "\u27cc\u27cb\u0001\u0000\u0000\u0000\u27cd\u05bb\u0001\u0000\u0000\u0000"+ + "\u27ce\u27d3\u0003\u05be\u02df\u0000\u27cf\u27d0\u0005\u0007\u0000\u0000"+ + "\u27d0\u27d2\u0003\u05be\u02df\u0000\u27d1\u27cf\u0001\u0000\u0000\u0000"+ + "\u27d2\u27d5\u0001\u0000\u0000\u0000\u27d3\u27d1\u0001\u0000\u0000\u0000"+ + "\u27d3\u27d4\u0001\u0000\u0000\u0000\u27d4\u05bd\u0001\u0000\u0000\u0000"+ + "\u27d5\u27d3\u0001\u0000\u0000\u0000\u27d6\u27d7\u0003\u05c2\u02e1\u0000"+ + "\u27d7\u27d8\u0003\u05aa\u02d5\u0000\u27d8\u27d9\u0003\u05c0\u02e0\u0000"+ + "\u27d9\u05bf\u0001\u0000\u0000\u0000\u27da\u27db\u0003\u055c\u02ae\u0000"+ + "\u27db\u05c1\u0001\u0000\u0000\u0000\u27dc\u27dd\u0003\u05c4\u02e2\u0000"+ + "\u27dd\u05c3\u0001\u0000\u0000\u0000\u27de\u27e1\u0003\u020c\u0106\u0000"+ + "\u27df\u27e1\u0005\u001e\u0000\u0000\u27e0\u27de\u0001\u0000\u0000\u0000"+ + "\u27e0\u27df\u0001\u0000\u0000\u0000\u27e1\u27e8\u0001\u0000\u0000\u0000"+ + "\u27e2\u27e3\u0005\u0005\u0000\u0000\u27e3\u27e4\u0003\u0650\u0328\u0000"+ + "\u27e4\u27e5\u0005\u0006\u0000\u0000\u27e5\u27e7\u0001\u0000\u0000\u0000"+ + "\u27e6\u27e2\u0001\u0000\u0000\u0000\u27e7\u27ea\u0001\u0000\u0000\u0000"+ + "\u27e8\u27e6\u0001\u0000\u0000\u0000\u27e8\u27e9\u0001\u0000\u0000\u0000"+ + "\u27e9\u05c5\u0001\u0000\u0000\u0000\u27ea\u27e8\u0001\u0000\u0000\u0000"+ + "\u27eb\u27ec\u0005\u00de\u0000\u0000\u27ec\u27ed\u0003\u064c\u0326\u0000"+ + "\u27ed\u27ee\u0005_\u0000\u0000\u27ee\u27ef\u0003\u05ac\u02d6\u0000\u27ef"+ + "\u27f0\u0003\u05c8\u02e4\u0000\u27f0\u27f1\u0003\u05ca\u02e5\u0000\u27f1"+ + "\u27f2\u0005\u01c8\u0000\u0000\u27f2\u27f3\u0005\u00de\u0000\u0000\u27f3"+ + "\u27f4\u0005\b\u0000\u0000\u27f4\u05c7\u0001\u0000\u0000\u0000\u27f5\u27f6"+ + "\u0005\u01f8\u0000\u0000\u27f6\u27f7\u0003\u048c\u0246\u0000\u27f7\u27f8"+ + "\u0005_\u0000\u0000\u27f8\u27f9\u0003\u05ac\u02d6\u0000\u27f9\u27fb\u0001"+ + "\u0000\u0000\u0000\u27fa\u27f5\u0001\u0000\u0000\u0000\u27fb\u27fe\u0001"+ + "\u0000\u0000\u0000\u27fc\u27fa\u0001\u0000\u0000\u0000\u27fc\u27fd\u0001"+ + "\u0000\u0000\u0000\u27fd\u05c9\u0001\u0000\u0000\u0000\u27fe\u27fc\u0001"+ + "\u0000\u0000\u0000\u27ff\u2803\u0001\u0000\u0000\u0000\u2800\u2801\u0005"+ + "<\u0000\u0000\u2801\u2803\u0003\u05ac\u02d6\u0000\u2802\u27ff\u0001\u0000"+ + "\u0000\u0000\u2802\u2800\u0001\u0000\u0000\u0000\u2803\u05cb\u0001\u0000"+ + "\u0000\u0000\u2804\u2805\u0005*\u0000\u0000\u2805\u2806\u0003\u05ce\u02e7"+ + "\u0000\u2806\u2807\u0003\u05d0\u02e8\u0000\u2807\u2808\u0003\u05d4\u02ea"+ + "\u0000\u2808\u2809\u0005\u01c8\u0000\u0000\u2809\u280a\u0005*\u0000\u0000"+ + "\u280a\u280b\u0005\b\u0000\u0000\u280b\u05cd\u0001\u0000\u0000\u0000\u280c"+ + "\u280f\u0001\u0000\u0000\u0000\u280d\u280f\u0003\u064a\u0325\u0000\u280e"+ + "\u280c\u0001\u0000\u0000\u0000\u280e\u280d\u0001\u0000\u0000\u0000\u280f"+ + "\u05cf\u0001\u0000\u0000\u0000\u2810\u2812\u0003\u05d2\u02e9\u0000\u2811"+ + "\u2810\u0001\u0000\u0000\u0000\u2812\u2813\u0001\u0000\u0000\u0000\u2813"+ + "\u2811\u0001\u0000\u0000\u0000\u2813\u2814\u0001\u0000\u0000\u0000\u2814"+ + "\u05d1\u0001\u0000\u0000\u0000\u2815\u2816\u0005h\u0000\u0000\u2816\u2817"+ + "\u0003\u0500\u0280\u0000\u2817\u2818\u0005_\u0000\u0000\u2818\u2819\u0003"+ + "\u05ac\u02d6\u0000\u2819\u05d3\u0001\u0000\u0000\u0000\u281a\u281e\u0001"+ + "\u0000\u0000\u0000\u281b\u281c\u0005<\u0000\u0000\u281c\u281e\u0003\u05ac"+ + "\u02d6\u0000\u281d\u281a\u0001\u0000\u0000\u0000\u281d\u281b\u0001\u0000"+ + "\u0000\u0000\u281e\u05d5\u0001\u0000\u0000\u0000\u281f\u2820\u0003\u0640"+ + "\u0320\u0000\u2820\u2821\u0003\u0604\u0302\u0000\u2821\u05d7\u0001\u0000"+ + "\u0000\u0000\u2822\u2823\u0003\u0640\u0320\u0000\u2823\u2824\u0005\u01f9"+ + "\u0000\u0000\u2824\u2825\u0003\u0652\u0329\u0000\u2825\u2826\u0003\u0604"+ + "\u0302\u0000\u2826\u05d9\u0001\u0000\u0000\u0000\u2827\u2828\u0003\u0640"+ + "\u0320\u0000\u2828\u2829\u0005@\u0000\u0000\u2829\u282a\u0003\u05dc\u02ee"+ + "\u0000\u282a\u282b\u0003\u0604\u0302\u0000\u282b\u05db\u0001\u0000\u0000"+ + "\u0000\u282c\u282d\u0003\u05e6\u02f3\u0000\u282d\u283d\u0005F\u0000\u0000"+ + "\u282e\u282f\u0003\u03ba\u01dd\u0000\u282f\u2830\u0003\u05e0\u02f0\u0000"+ + "\u2830\u283e\u0001\u0000\u0000\u0000\u2831\u283e\u0003\u03c0\u01e0\u0000"+ + "\u2832\u283e\u0003\u036e\u01b7\u0000\u2833\u2834\u0005\u00cc\u0000\u0000"+ + "\u2834\u2835\u0003\u048c\u0246\u0000\u2835\u2836\u0003\u05de\u02ef\u0000"+ + "\u2836\u283e\u0001\u0000\u0000\u0000\u2837\u2838\u0003\u05e2\u02f1\u0000"+ + "\u2838\u2839\u0003\u048c\u0246\u0000\u2839\u283a\u0005\u001a\u0000\u0000"+ + "\u283a\u283b\u0003\u048c\u0246\u0000\u283b\u283c\u0003\u05e4\u02f2\u0000"+ + "\u283c\u283e\u0001\u0000\u0000\u0000\u283d\u282e\u0001\u0000\u0000\u0000"+ + "\u283d\u2831\u0001\u0000\u0000\u0000\u283d\u2832\u0001\u0000\u0000\u0000"+ + "\u283d\u2833\u0001\u0000\u0000\u0000\u283d\u2837\u0001\u0000\u0000\u0000"+ + "\u283e\u05dd\u0001\u0000\u0000\u0000\u283f\u2843\u0001\u0000\u0000\u0000"+ + "\u2840\u2841\u0005f\u0000\u0000\u2841\u2843\u0003\u0500\u0280\u0000\u2842"+ + "\u283f\u0001\u0000\u0000\u0000\u2842\u2840\u0001\u0000\u0000\u0000\u2843"+ + "\u05df\u0001\u0000\u0000\u0000\u2844\u2851\u0001\u0000\u0000\u0000\u2845"+ + "\u2846\u0005\u0003\u0000\u0000\u2846\u284b\u0003\u048c\u0246\u0000\u2847"+ + "\u2848\u0005\u0007\u0000\u0000\u2848\u284a\u0003\u048c\u0246\u0000\u2849"+ + "\u2847\u0001\u0000\u0000\u0000\u284a\u284d\u0001\u0000\u0000\u0000\u284b"+ + "\u2849\u0001\u0000\u0000\u0000\u284b\u284c\u0001\u0000\u0000\u0000\u284c"+ + "\u284e\u0001\u0000\u0000\u0000\u284d\u284b\u0001\u0000\u0000\u0000\u284e"+ + "\u284f\u0005\u0004\u0000\u0000\u284f\u2851\u0001\u0000\u0000\u0000\u2850"+ + "\u2844\u0001\u0000\u0000\u0000\u2850\u2845\u0001\u0000\u0000\u0000\u2851"+ + "\u05e1\u0001\u0000\u0000\u0000\u2852\u2855\u0001\u0000\u0000\u0000\u2853"+ + "\u2855\u0005\u01fa\u0000\u0000\u2854\u2852\u0001\u0000\u0000\u0000\u2854"+ + "\u2853\u0001\u0000\u0000\u0000\u2855\u05e3\u0001\u0000\u0000\u0000\u2856"+ + "\u285a\u0001\u0000\u0000\u0000\u2857\u2858\u0005\u0095\u0000\u0000\u2858"+ + "\u285a\u0003\u048c\u0246\u0000\u2859\u2856\u0001\u0000\u0000\u0000\u2859"+ + "\u2857\u0001\u0000\u0000\u0000\u285a\u05e5\u0001\u0000\u0000\u0000\u285b"+ + "\u285c\u0003\u020a\u0105\u0000\u285c\u05e7\u0001\u0000\u0000\u0000\u285d"+ + "\u285e\u0003\u0640\u0320\u0000\u285e\u285f\u0005\u01fb\u0000\u0000\u285f"+ + "\u2860\u0003\u05e6\u02f3\u0000\u2860\u2861\u0003\u05ea\u02f5\u0000\u2861"+ + "\u2862\u0005F\u0000\u0000\u2862\u2863\u0005%\u0000\u0000\u2863\u2864\u0003"+ + "\u048c\u0246\u0000\u2864\u2865\u0003\u0604\u0302\u0000\u2865\u05e9\u0001"+ + "\u0000\u0000\u0000\u2866\u286a\u0001\u0000\u0000\u0000\u2867\u2868\u0005"+ + "\u01fc\u0000\u0000\u2868\u286a\u0003\u054c\u02a6\u0000\u2869\u2866\u0001"+ + "\u0000\u0000\u0000\u2869\u2867\u0001\u0000\u0000\u0000\u286a\u05eb\u0001"+ + "\u0000\u0000\u0000\u286b\u286c\u0003\u05ee\u02f7\u0000\u286c\u286d\u0003"+ + "\u0642\u0321\u0000\u286d\u286e\u0003\u0644\u0322\u0000\u286e\u286f\u0005"+ + "\b\u0000\u0000\u286f\u05ed\u0001\u0000\u0000\u0000\u2870\u2871\u0007B"+ + "\u0000\u0000\u2871\u05ef\u0001\u0000\u0000\u0000\u2872\u287e\u0005\u01fe"+ + "\u0000\u0000\u2873\u2874\u0005\u0107\u0000\u0000\u2874\u287f\u0003\u064a"+ + "\u0325\u0000\u2875\u287b\u0005\u01ff\u0000\u0000\u2876\u2877\u0005\u00cc"+ + "\u0000\u0000\u2877\u2878\u0003\u048c\u0246\u0000\u2878\u2879\u0003\u05de"+ + "\u02ef\u0000\u2879\u287c\u0001\u0000\u0000\u0000\u287a\u287c\u0003\u03c0"+ + "\u01e0\u0000\u287b\u2876\u0001\u0000\u0000\u0000\u287b\u287a\u0001\u0000"+ + "\u0000\u0000\u287c\u287f\u0001\u0000\u0000\u0000\u287d\u287f\u0003\u05f2"+ + "\u02f9\u0000\u287e\u2873\u0001\u0000\u0000\u0000\u287e\u2875\u0001\u0000"+ + "\u0000\u0000\u287e\u287d\u0001\u0000\u0000\u0000\u287f\u2880\u0001\u0000"+ + "\u0000\u0000\u2880\u2881\u0005\b\u0000\u0000\u2881\u05f1\u0001\u0000\u0000"+ + "\u0000\u2882\u2885\u0001\u0000\u0000\u0000\u2883\u2885\u0003\u064a\u0325"+ + "\u0000\u2884\u2882\u0001\u0000\u0000\u0000\u2884\u2883\u0001\u0000\u0000"+ + "\u0000\u2885\u05f3\u0001\u0000\u0000\u0000\u2886\u2887\u0005\u0200\u0000"+ + "\u0000\u2887\u2888\u0003\u05f6\u02fb\u0000\u2888\u2889\u0003\u054e\u02a7"+ + "\u0000\u2889\u288a\u0003\u05f8\u02fc\u0000\u288a\u288b\u0003\u05fa\u02fd"+ + "\u0000\u288b\u288c\u0005\b\u0000\u0000\u288c\u28a1\u0001\u0000\u0000\u0000"+ + "\u288d\u288e\u0005\u0200\u0000\u0000\u288e\u288f\u0003\u05f6\u02fb\u0000"+ + "\u288f\u2890\u0003\u0566\u02b3\u0000\u2890\u2891\u0003\u05fa\u02fd\u0000"+ + "\u2891\u2892\u0005\b\u0000\u0000\u2892\u28a1\u0001\u0000\u0000\u0000\u2893"+ + "\u2894\u0005\u0200\u0000\u0000\u2894\u2895\u0003\u05f6\u02fb\u0000\u2895"+ + "\u2896\u0005\u0201\u0000\u0000\u2896\u2897\u0003\u054e\u02a7\u0000\u2897"+ + "\u2898\u0003\u05fa\u02fd\u0000\u2898\u2899\u0005\b\u0000\u0000\u2899\u28a1"+ + "\u0001\u0000\u0000\u0000\u289a\u289b\u0005\u0200\u0000\u0000\u289b\u289c"+ + "\u0003\u05f6\u02fb\u0000\u289c\u289d\u0003\u05fa\u02fd\u0000\u289d\u289e"+ + "\u0005\b\u0000\u0000\u289e\u28a1\u0001\u0000\u0000\u0000\u289f\u28a1\u0005"+ + "\u0200\u0000\u0000\u28a0\u2886\u0001\u0000\u0000\u0000\u28a0\u288d\u0001"+ + "\u0000\u0000\u0000\u28a0\u2893\u0001\u0000\u0000\u0000\u28a0\u289a\u0001"+ + "\u0000\u0000\u0000\u28a0\u289f\u0001\u0000\u0000\u0000\u28a1\u05f5\u0001"+ + "\u0000\u0000\u0000\u28a2\u28ab\u0001\u0000\u0000\u0000\u28a3\u28ab\u0001"+ + "\u0000\u0000\u0000\u28a4\u28ab\u0005\u0202\u0000\u0000\u28a5\u28ab\u0005"+ + "\u0203\u0000\u0000\u28a6\u28ab\u0005\u0204\u0000\u0000\u28a7\u28ab\u0005"+ + "\u0205\u0000\u0000\u28a8\u28ab\u0005\u0206\u0000\u0000\u28a9\u28ab\u0005"+ + "\u0207\u0000\u0000\u28aa\u28a2\u0001\u0000\u0000\u0000\u28aa\u28a3\u0001"+ + "\u0000\u0000\u0000\u28aa\u28a4\u0001\u0000\u0000\u0000\u28aa\u28a5\u0001"+ + "\u0000\u0000\u0000\u28aa\u28a6\u0001\u0000\u0000\u0000\u28aa\u28a7\u0001"+ + "\u0000\u0000\u0000\u28aa\u28a8\u0001\u0000\u0000\u0000\u28aa\u28a9\u0001"+ + "\u0000\u0000\u0000\u28ab\u05f7\u0001\u0000\u0000\u0000\u28ac\u28b4\u0001"+ + "\u0000\u0000\u0000\u28ad\u28ae\u0005\u0007\u0000\u0000\u28ae\u28b0\u0003"+ + "\u048c\u0246\u0000\u28af\u28ad\u0001\u0000\u0000\u0000\u28b0\u28b1\u0001"+ + "\u0000\u0000\u0000\u28b1\u28af\u0001\u0000\u0000\u0000\u28b1\u28b2\u0001"+ + "\u0000\u0000\u0000\u28b2\u28b4\u0001\u0000\u0000\u0000\u28b3\u28ac\u0001"+ + "\u0000\u0000\u0000\u28b3\u28af\u0001\u0000\u0000\u0000\u28b4\u05f9\u0001"+ + "\u0000\u0000\u0000\u28b5\u28b9\u0001\u0000\u0000\u0000\u28b6\u28b7\u0005"+ + "f\u0000\u0000\u28b7\u28b9\u0003\u05fe\u02ff\u0000\u28b8\u28b5\u0001\u0000"+ + "\u0000\u0000\u28b8\u28b6\u0001\u0000\u0000\u0000\u28b9\u05fb\u0001\u0000"+ + "\u0000\u0000\u28ba\u28bb\u0003\u0566\u02b3\u0000\u28bb\u28bc\u0005\f\u0000"+ + "\u0000\u28bc\u28bd\u0003\u048c\u0246\u0000\u28bd\u05fd\u0001\u0000\u0000"+ + "\u0000\u28be\u28c3\u0003\u05fc\u02fe\u0000\u28bf\u28c0\u0005\u0007\u0000"+ + "\u0000\u28c0\u28c2\u0003\u05fc\u02fe\u0000\u28c1\u28bf\u0001\u0000\u0000"+ + "\u0000\u28c2\u28c5\u0001\u0000\u0000\u0000\u28c3\u28c1\u0001\u0000\u0000"+ + "\u0000\u28c3\u28c4\u0001\u0000\u0000\u0000\u28c4\u05ff\u0001\u0000\u0000"+ + "\u0000\u28c5\u28c3\u0001\u0000\u0000\u0000\u28c6\u28c7\u0005\u0208\u0000"+ + "\u0000\u28c7\u28c8\u0003\u064a\u0325\u0000\u28c8\u28c9\u0003\u0602\u0301"+ + "\u0000\u28c9\u28ca\u0005\b\u0000\u0000\u28ca\u0601\u0001\u0000\u0000\u0000"+ + "\u28cb\u28cf\u0001\u0000\u0000\u0000\u28cc\u28cd\u0005\u0007\u0000\u0000"+ + "\u28cd\u28cf\u0003\u064a\u0325\u0000\u28ce\u28cb\u0001\u0000\u0000\u0000"+ + "\u28ce\u28cc\u0001\u0000\u0000\u0000\u28cf\u0603\u0001\u0000\u0000\u0000"+ + "\u28d0\u28d1\u0005\u0209\u0000\u0000\u28d1\u28d2\u0003\u05ac\u02d6\u0000"+ + "\u28d2\u28d3\u0005\u01c8\u0000\u0000\u28d3\u28d4\u0005\u0209\u0000\u0000"+ + "\u28d4\u28d5\u0003\u0642\u0321\u0000\u28d5\u28d6\u0005\b\u0000\u0000\u28d6"+ + "\u0605\u0001\u0000\u0000\u0000\u28d7\u28d8\u0003\u0654\u032a\u0000\u28d8"+ + "\u28d9\u0005\b\u0000\u0000\u28d9\u0607\u0001\u0000\u0000\u0000\u28da\u28db"+ + "\u0005\u00cc\u0000\u0000\u28db\u28e3\u0003\u048c\u0246\u0000\u28dc\u28dd"+ + "\u0003\u060e\u0307\u0000\u28dd\u28de\u0003\u060a\u0305\u0000\u28de\u28e4"+ + "\u0001\u0000\u0000\u0000\u28df\u28e0\u0003\u060a\u0305\u0000\u28e0\u28e1"+ + "\u0003\u060e\u0307\u0000\u28e1\u28e4\u0001\u0000\u0000\u0000\u28e2\u28e4"+ + "\u0001\u0000\u0000\u0000\u28e3\u28dc\u0001\u0000\u0000\u0000\u28e3\u28df"+ + "\u0001\u0000\u0000\u0000\u28e3\u28e2\u0001\u0000\u0000\u0000\u28e4\u28e5"+ + "\u0001\u0000\u0000\u0000\u28e5\u28e6\u0005\b\u0000\u0000\u28e6\u0609\u0001"+ + "\u0000\u0000\u0000\u28e7\u28eb\u0001\u0000\u0000\u0000\u28e8\u28e9\u0005"+ + "f\u0000\u0000\u28e9\u28eb\u0003\u060c\u0306\u0000\u28ea\u28e7\u0001\u0000"+ + "\u0000\u0000\u28ea\u28e8\u0001\u0000\u0000\u0000\u28eb\u060b\u0001\u0000"+ + "\u0000\u0000\u28ec\u28f1\u0003\u048c\u0246\u0000\u28ed\u28ee\u0005\u0007"+ + "\u0000\u0000\u28ee\u28f0\u0003\u048c\u0246\u0000\u28ef\u28ed\u0001\u0000"+ + "\u0000\u0000\u28f0\u28f3\u0001\u0000\u0000\u0000\u28f1\u28ef\u0001\u0000"+ + "\u0000\u0000\u28f1\u28f2\u0001\u0000\u0000\u0000\u28f2\u060d\u0001\u0000"+ + "\u0000\u0000\u28f3\u28f1\u0001\u0000\u0000\u0000\u28f4\u28fb\u0001\u0000"+ + "\u0000\u0000\u28f5\u28f7\u0005I\u0000\u0000\u28f6\u28f8\u0005\u0155\u0000"+ + "\u0000\u28f7\u28f6\u0001\u0000\u0000\u0000\u28f7\u28f8\u0001\u0000\u0000"+ + "\u0000\u28f8\u28f9\u0001\u0000\u0000\u0000\u28f9\u28fb\u0003\u061e\u030f"+ + "\u0000\u28fa\u28f4\u0001\u0000\u0000\u0000\u28fa\u28f5\u0001\u0000\u0000"+ + "\u0000\u28fb\u060f\u0001\u0000\u0000\u0000\u28fc\u290e\u0005\u020a\u0000"+ + "\u0000\u28fd\u28fe\u0003\u0632\u0319\u0000\u28fe\u28ff\u0003\u0618\u030c"+ + "\u0000\u28ff\u2905\u0005@\u0000\u0000\u2900\u2906\u0003\u03c0\u01e0\u0000"+ + "\u2901\u2902\u0005\u00cc\u0000\u0000\u2902\u2903\u0003\u064a\u0325\u0000"+ + "\u2903\u2904\u0003\u0616\u030b\u0000\u2904\u2906\u0001\u0000\u0000\u0000"+ + "\u2905\u2900\u0001\u0000\u0000\u0000\u2905\u2901\u0001\u0000\u0000\u0000"+ + "\u2906\u290f\u0001\u0000\u0000\u0000\u2907\u290c\u0003\u055c\u02ae\u0000"+ + "\u2908\u2909\u0005\u0003\u0000\u0000\u2909\u290a\u0003\u0614\u030a\u0000"+ + "\u290a\u290b\u0005\u0004\u0000\u0000\u290b\u290d\u0001\u0000\u0000\u0000"+ + "\u290c\u2908\u0001\u0000\u0000\u0000\u290c\u290d\u0001\u0000\u0000\u0000"+ + "\u290d\u290f\u0001\u0000\u0000\u0000\u290e\u28fd\u0001\u0000\u0000\u0000"+ + "\u290e\u2907\u0001\u0000\u0000\u0000\u290f\u2910\u0001\u0000\u0000\u0000"+ + "\u2910\u2911\u0005\b\u0000\u0000\u2911\u0611\u0001\u0000\u0000\u0000\u2912"+ + "\u2913\u0003\u055c\u02ae\u0000\u2913\u2914\u0005\u0016\u0000\u0000\u2914"+ + "\u2915\u0003\u048c\u0246\u0000\u2915\u2918\u0001\u0000\u0000\u0000\u2916"+ + "\u2918\u0003\u048c\u0246\u0000\u2917\u2912\u0001\u0000\u0000\u0000\u2917"+ + "\u2916\u0001\u0000\u0000\u0000\u2918\u0613\u0001\u0000\u0000\u0000\u2919"+ + "\u291e\u0003\u0612\u0309\u0000\u291a\u291b\u0005\u0007\u0000\u0000\u291b"+ + "\u291d\u0003\u0612\u0309\u0000\u291c\u291a\u0001\u0000\u0000\u0000\u291d"+ + "\u2920\u0001\u0000\u0000\u0000\u291e\u291c\u0001\u0000\u0000\u0000\u291e"+ + "\u291f\u0001\u0000\u0000\u0000\u291f\u0615\u0001\u0000\u0000\u0000\u2920"+ + "\u291e\u0001\u0000\u0000\u0000\u2921\u2925\u0001\u0000\u0000\u0000\u2922"+ + "\u2923\u0005f\u0000\u0000\u2923\u2925\u0003\u0500\u0280\u0000\u2924\u2921"+ + "\u0001\u0000\u0000\u0000\u2924\u2922\u0001\u0000\u0000\u0000\u2925\u0617"+ + "\u0001\u0000\u0000\u0000\u2926\u292b\u0001\u0000\u0000\u0000\u2927\u2928"+ + "\u0003\u061a\u030d\u0000\u2928\u2929\u0005\u013f\u0000\u0000\u2929\u292b"+ + "\u0001\u0000\u0000\u0000\u292a\u2926\u0001\u0000\u0000\u0000\u292a\u2927"+ + "\u0001\u0000\u0000\u0000\u292b\u0619\u0001\u0000\u0000\u0000\u292c\u292f"+ + "\u0001\u0000\u0000\u0000\u292d\u292f\u0005\u0108\u0000\u0000\u292e\u292c"+ + "\u0001\u0000\u0000\u0000\u292e\u292d\u0001\u0000\u0000\u0000\u292f\u061b"+ + "\u0001\u0000\u0000\u0000\u2930\u2931\u0005?\u0000\u0000\u2931\u2932\u0003"+ + "\u0622\u0311\u0000\u2932\u2933\u0003\u0620\u0310\u0000\u2933\u2934\u0003"+ + "\u0632\u0319\u0000\u2934\u2935\u0005I\u0000\u0000\u2935\u2936\u0003\u061e"+ + "\u030f\u0000\u2936\u2937\u0005\b\u0000\u0000\u2937\u061d\u0001\u0000\u0000"+ + "\u0000\u2938\u2939\u0003\u0500\u0280\u0000\u2939\u061f\u0001\u0000\u0000"+ + "\u0000\u293a\u293e\u0001\u0000\u0000\u0000\u293b\u293e\u0005B\u0000\u0000"+ + "\u293c\u293e\u0005F\u0000\u0000\u293d\u293a\u0001\u0000\u0000\u0000\u293d"+ + "\u293b\u0001\u0000\u0000\u0000\u293d\u293c\u0001\u0000\u0000\u0000\u293e"+ + "\u0621\u0001\u0000\u0000\u0000\u293f\u2951\u0001\u0000\u0000\u0000\u2940"+ + "\u2951\u0001\u0000\u0000\u0000\u2941\u2951\u0005\u0107\u0000\u0000\u2942"+ + "\u2951\u0005\u0120\u0000\u0000\u2943\u2951\u0005\u00d1\u0000\u0000\u2944"+ + "\u2951\u0005\u00f2\u0000\u0000\u2945\u2946\u0005\u0084\u0000\u0000\u2946"+ + "\u2951\u0003\u048c\u0246\u0000\u2947\u2948\u0005\u012e\u0000\u0000\u2948"+ + "\u2951\u0003\u048c\u0246\u0000\u2949\u2951\u0003\u048c\u0246\u0000\u294a"+ + "\u2951\u0005 \u0000\u0000\u294b\u294e\u0007C\u0000\u0000\u294c\u294f\u0003"+ + "\u048c\u0246\u0000\u294d\u294f\u0005 \u0000\u0000\u294e\u294c\u0001\u0000"+ + "\u0000\u0000\u294e\u294d\u0001\u0000\u0000\u0000\u294e\u294f\u0001\u0000"+ + "\u0000\u0000\u294f\u2951\u0001\u0000\u0000\u0000\u2950\u293f\u0001\u0000"+ + "\u0000\u0000\u2950\u2940\u0001\u0000\u0000\u0000\u2950\u2941\u0001\u0000"+ + "\u0000\u0000\u2950\u2942\u0001\u0000\u0000\u0000\u2950\u2943\u0001\u0000"+ + "\u0000\u0000\u2950\u2944\u0001\u0000\u0000\u0000\u2950\u2945\u0001\u0000"+ + "\u0000\u0000\u2950\u2947\u0001\u0000\u0000\u0000\u2950\u2949\u0001\u0000"+ + "\u0000\u0000\u2950\u294a\u0001\u0000\u0000\u0000\u2950\u294b\u0001\u0000"+ + "\u0000\u0000\u2951\u0623\u0001\u0000\u0000\u0000\u2952\u2953\u0005\u0104"+ + "\u0000\u0000\u2953\u2954\u0003\u0622\u0311\u0000\u2954\u2955\u0003\u0632"+ + "\u0319\u0000\u2955\u2956\u0005\b\u0000\u0000\u2956\u0625\u0001\u0000\u0000"+ + "\u0000\u2957\u2958\u0005\u009f\u0000\u0000\u2958\u2959\u0003\u0632\u0319"+ + "\u0000\u2959\u295a\u0005\b\u0000\u0000\u295a\u0627\u0001\u0000\u0000\u0000"+ + "\u295b\u295c\u0005P\u0000\u0000\u295c\u295d\u0005\b\u0000\u0000\u295d"+ + "\u0629\u0001\u0000\u0000\u0000\u295e\u295f\u0005\u00a3\u0000\u0000\u295f"+ + "\u2960\u0003\u062e\u0317\u0000\u2960\u2961\u0005\b\u0000\u0000\u2961\u062b"+ + "\u0001\u0000\u0000\u0000\u2962\u2963\u0005\u013a\u0000\u0000\u2963\u2964"+ + "\u0003\u062e\u0317\u0000\u2964\u2965\u0005\b\u0000\u0000\u2965\u062d\u0001"+ + "\u0000\u0000\u0000\u2966\u2968\u0005#\u0000\u0000\u2967\u2969\u0005\u0108"+ + "\u0000\u0000\u2968\u2967\u0001\u0000\u0000\u0000\u2968\u2969\u0001\u0000"+ + "\u0000\u0000\u2969\u296a\u0001\u0000\u0000\u0000\u296a\u296d\u0005\u009b"+ + "\u0000\u0000\u296b\u296d\u0001\u0000\u0000\u0000\u296c\u2966\u0001\u0000"+ + "\u0000\u0000\u296c\u296b\u0001\u0000\u0000\u0000\u296d\u062f\u0001\u0000"+ + "\u0000\u0000\u296e\u296f\u0005\u0148\u0000\u0000\u296f\u2970\u0003\u020c"+ + "\u0106\u0000\u2970\u2971\u0005`\u0000\u0000\u2971\u2972\u00057\u0000\u0000"+ + "\u2972\u2973\u0005\b\u0000\u0000\u2973\u297b\u0001\u0000\u0000\u0000\u2974"+ + "\u2977\u0005\u0134\u0000\u0000\u2975\u2978\u0003\u020c\u0106\u0000\u2976"+ + "\u2978\u0005 \u0000\u0000\u2977\u2975\u0001\u0000\u0000\u0000\u2977\u2976"+ + "\u0001\u0000\u0000\u0000\u2978\u2979\u0001\u0000\u0000\u0000\u2979\u297b"+ + "\u0005\b\u0000\u0000\u297a\u296e\u0001\u0000\u0000\u0000\u297a\u2974\u0001"+ + "\u0000\u0000\u0000\u297b\u0631\u0001\u0000\u0000\u0000\u297c\u297f\u0003"+ + "\u055c\u02ae\u0000\u297d\u297f\u0005\u001e\u0000\u0000\u297e\u297c\u0001"+ + "\u0000\u0000\u0000\u297e\u297d\u0001\u0000\u0000\u0000\u297f\u0633\u0001"+ + "\u0000\u0000\u0000\u2980\u2984\u0001\u0000\u0000\u0000\u2981\u2982\u0005"+ + "\u0207\u0000\u0000\u2982\u2984\u0003\u0636\u031b\u0000\u2983\u2980\u0001"+ + "\u0000\u0000\u0000\u2983\u2981\u0001\u0000\u0000\u0000\u2984\u0635\u0001"+ + "\u0000\u0000\u0000\u2985\u2987\u0003\u0638\u031c\u0000\u2986\u2985\u0001"+ + "\u0000\u0000\u0000\u2987\u2988\u0001\u0000\u0000\u0000\u2988\u2986\u0001"+ + "\u0000\u0000\u0000\u2988\u2989\u0001\u0000\u0000\u0000\u2989\u0637\u0001"+ + "\u0000\u0000\u0000\u298a\u298b\u0005h\u0000\u0000\u298b\u298c\u0003\u063a"+ + "\u031d\u0000\u298c\u298d\u0005_\u0000\u0000\u298d\u298e\u0003\u05ac\u02d6"+ + "\u0000\u298e\u0639\u0001\u0000\u0000\u0000\u298f\u2994\u0003\u063c\u031e"+ + "\u0000\u2990\u2991\u0005T\u0000\u0000\u2991\u2993\u0003\u063c\u031e\u0000"+ + "\u2992\u2990\u0001\u0000\u0000\u0000\u2993\u2996\u0001\u0000\u0000\u0000"+ + "\u2994\u2992\u0001\u0000\u0000\u0000\u2994\u2995\u0001\u0000\u0000\u0000"+ + "\u2995\u063b\u0001\u0000\u0000\u0000\u2996\u2994\u0001\u0000\u0000\u0000"+ + "\u2997\u299b\u0003\u0646\u0323\u0000\u2998\u2999\u0005\u0201\u0000\u0000"+ + "\u2999\u299b\u0003\u054e\u02a7\u0000\u299a\u2997\u0001\u0000\u0000\u0000"+ + "\u299a\u2998\u0001\u0000\u0000\u0000\u299b\u063d\u0001\u0000\u0000\u0000"+ + "\u299c\u299f\u0001\u0000\u0000\u0000\u299d\u299f\u0003\u0588\u02c4\u0000"+ + "\u299e\u299c\u0001\u0000\u0000\u0000\u299e\u299d\u0001\u0000\u0000\u0000"+ + "\u299f\u063f\u0001\u0000\u0000\u0000\u29a0\u29a3\u0001\u0000\u0000\u0000"+ + "\u29a1\u29a3\u0003\u0588\u02c4\u0000\u29a2\u29a0\u0001\u0000\u0000\u0000"+ + "\u29a2\u29a1\u0001\u0000\u0000\u0000\u29a3\u0641\u0001\u0000\u0000\u0000"+ + "\u29a4\u29a7\u0001\u0000\u0000\u0000\u29a5\u29a7\u0003\u0646\u0323\u0000"+ + "\u29a6\u29a4\u0001\u0000\u0000\u0000\u29a6\u29a5\u0001\u0000\u0000\u0000"+ + "\u29a7\u0643\u0001\u0000\u0000\u0000\u29a8\u29a9\u0005h\u0000\u0000\u29a9"+ + "\u29ac\u0003\u064e\u0327\u0000\u29aa\u29ac\u0001\u0000\u0000\u0000\u29ab"+ + "\u29a8\u0001\u0000\u0000\u0000\u29ab\u29aa\u0001\u0000\u0000\u0000\u29ac"+ + "\u0645\u0001\u0000\u0000\u0000\u29ad\u29b0\u0003\u055c\u02ae\u0000\u29ae"+ + "\u29b0\u0003\u0648\u0324\u0000\u29af\u29ad\u0001\u0000\u0000\u0000\u29af"+ + "\u29ae\u0001\u0000\u0000\u0000\u29b0\u0647\u0001\u0000\u0000\u0000\u29b1"+ + "\u29b2\u0007D\u0000\u0000\u29b2\u0649\u0001\u0000\u0000\u0000\u29b3\u29b4"+ + "\u0003\u0530\u0298\u0000\u29b4\u29b5\u0003\u03d8\u01ec\u0000\u29b5\u29b6"+ + "\u0003\u0420\u0210\u0000\u29b6\u29b7\u0003\u0448\u0224\u0000\u29b7\u29b8"+ + "\u0003\u0402\u0201\u0000\u29b8\u29b9\u0003\u0410\u0208\u0000\u29b9\u29ba"+ + "\u0003\u04d8\u026c\u0000\u29ba\u064b\u0001\u0000\u0000\u0000\u29bb\u29bc"+ + "\u0003\u064a\u0325\u0000\u29bc\u064d\u0001\u0000\u0000\u0000\u29bd\u29be"+ + "\u0003\u064a\u0325\u0000\u29be\u064f\u0001\u0000\u0000\u0000\u29bf\u29c0"+ + "\u0003\u048c\u0246\u0000\u29c0\u0651\u0001\u0000\u0000\u0000\u29c1\u29c2"+ + "\u0003\u048c\u0246\u0000\u29c2\u0653\u0001\u0000\u0000\u0000\u29c3\u29c4"+ + "\u0003\b\u0004\u0000\u29c4\u29c5\u0003\u0656\u032b\u0000\u29c5\u0655\u0001"+ + "\u0000\u0000\u0000\u29c6\u29c7\u0005I\u0000\u0000\u29c7\u29c8\u0003\u03da"+ + "\u01ed\u0000\u29c8\u29c9\u0003\u061e\u030f\u0000\u29c9\u29cc\u0001\u0000"+ + "\u0000\u0000\u29ca\u29cc\u0001\u0000\u0000\u0000\u29cb\u29c6\u0001\u0000"+ + "\u0000\u0000\u29cb\u29ca\u0001\u0000\u0000\u0000\u29cc\u0657\u0001\u0000"+ + "\u0000\u0000\u29cd\u29ce\u0005\t\u0000\u0000\u29ce\u29d9\u0005\u0001\u0000"+ + "\u0000\u29cf\u29d2\u0005\t\u0000\u0000\u29d0\u29d3\u0003\u055c\u02ae\u0000"+ + "\u29d1\u29d3\u0003\u0570\u02b8\u0000\u29d2\u29d0\u0001\u0000\u0000\u0000"+ + "\u29d2\u29d1\u0001\u0000\u0000\u0000\u29d3\u29d9\u0001\u0000\u0000\u0000"+ + "\u29d4\u29d5\u0005\n\u0000\u0000\u29d5\u29d9\u0005\u0001\u0000\u0000\u29d6"+ + "\u29d7\u0005\n\u0000\u0000\u29d7\u29d9\u0005\u0295\u0000\u0000\u29d8\u29cd"+ + "\u0001\u0000\u0000\u0000\u29d8\u29cf\u0001\u0000\u0000\u0000\u29d8\u29d4"+ + "\u0001\u0000\u0000\u0000\u29d8\u29d6\u0001\u0000\u0000\u0000\u29d9\u0659"+ + "\u0001\u0000\u0000\u0000\u02eb\u0663\u0667\u06e7\u06eb\u06f8\u06fd\u0703"+ + "\u0709\u0718\u0724\u0736\u073b\u0745\u075d\u0764\u076a\u076f\u0778\u077c"+ + "\u0788\u07a7\u07ae\u07b6\u07bb\u07c2\u07c8\u07d9\u07de\u07e2\u07ef\u07f3"+ + "\u07f8\u07fd\u0809\u0812\u081f\u0824\u082f\u083a\u083f\u084a\u0855\u085e"+ + "\u0868\u0877\u0883\u0888\u088f\u089a\u099c\u09a3\u09a8\u09ad\u09b2\u09ba"+ + "\u09c3\u09ca\u09d4\u09d6\u09db\u09e1\u09e7\u09e9\u0a05\u0a0f\u0a1c\u0a28"+ + "\u0a36\u0a3b\u0a53\u0a59\u0a5e\u0a65\u0a6a\u0a90\u0a94\u0a9b\u0a9f\u0aa6"+ + "\u0ab4\u0abb\u0ac6\u0ae7\u0af1\u0af5\u0afc\u0b03\u0b0b\u0b11\u0b15\u0b1f"+ + "\u0b26\u0b31\u0b51\u0b59\u0b5e\u0b65\u0b6f\u0b79\u0b8d\u0b9c\u0bb5\u0bba"+ + "\u0bc1\u0bc8\u0bd3\u0bd8\u0bdf\u0bea\u0bf2\u0bfd\u0c0d\u0c15\u0c19\u0c27"+ + "\u0c38\u0c3d\u0c44\u0c4d\u0c50\u0c55\u0c5c\u0c67\u0c74\u0c81\u0c93\u0c96"+ + "\u0c9f\u0cae\u0cbd\u0cc6\u0ccd\u0cd4\u0cd9\u0cf7\u0cf9\u0cfd\u0d05\u0d0c"+ + "\u0d1a\u0d1e\u0d22\u0d27\u0d2d\u0d31\u0d35\u0d42\u0d48\u0d51\u0d5a\u0d64"+ + "\u0d6f\u0ddd\u0def\u0df4\u0df8\u0e09\u0e11\u0e18\u0e25\u0e2f\u0e51\u0e56"+ + "\u0e5b\u0e5f\u0e67\u0e69\u0ea3\u0eb4\u0ebc\u0ed3\u0ed7\u0eeb\u0f10\u0f19"+ + "\u0f1e\u0f23\u0f28\u0f2d\u0f62\u0f68\u0f6f\u0f79\u0f7e\u0f83\u0f95\u0f99"+ + "\u0fa3\u0fa9\u0faf\u0fb6\u0fbb\u0fc0\u0fce\u0fea\u0ff1\u0fff\u100e\u1083"+ + "\u108e\u1094\u109c\u10a7\u10b0\u10b7\u10df\u10e5\u10fa\u1116\u111a\u111f"+ + "\u1128\u112c\u1147\u114e\u115d\u1171\u1185\u11e2\u11fb\u1202\u1212\u121b"+ + "\u1220\u1226\u122d\u123b\u12d0\u12d4\u1331\u1336\u133a\u1340\u1384\u138a"+ + "\u13a7\u13b8\u13bf\u13cb\u1407\u140e\u1414\u141a\u1434\u143a\u1440\u144b"+ + "\u1457\u1474\u149b\u149f\u14a3\u14a7\u14ac\u14b3\u14c1\u14ce\u14d6\u14dd"+ + "\u14e3\u14e7\u14ec\u14f3\u1501\u1503\u150a\u150e\u1517\u151f\u1528\u152a"+ + "\u152e\u1537\u153c\u1542\u1547\u154b\u1550\u1556\u155c\u1562\u1568\u156d"+ + "\u157c\u1585\u1590\u1596\u15bd\u15c7\u15ce\u15d9\u15df\u15e9\u15f5\u15f9"+ + "\u161f\u162d\u163b\u1653\u165a\u1664\u1670\u1675\u1699\u16a0\u16af\u16de"+ + "\u1703\u170e\u171f\u18f5\u18f9\u18fe\u1939\u193d\u1a18\u1a27\u1a32\u1a39"+ + "\u1afa\u1b04\u1b0c\u1b29\u1b39\u1b63\u1b71\u1b87\u1b8e\u1b96\u1b9a\u1ba1"+ + "\u1baa\u1bb3\u1be7\u1bec\u1bf8\u1bfc\u1c01\u1c06\u1c0a\u1c0e\u1c13\u1c23"+ + "\u1c2b\u1c30\u1c3d\u1c42\u1c49\u1c53\u1c57\u1c62\u1c6d\u1c75\u1c7c\u1ca3"+ + "\u1cab\u1caf\u1d00\u1d1c\u1d21\u1d30\u1d3c\u1d43\u1d4d\u1d52\u1d56\u1d5a"+ + "\u1d5e\u1d62\u1d69\u1d73\u1d78\u1d8a\u1d95\u1d9c\u1da4\u1da9\u1db6\u1dbc"+ + "\u1dd9\u1de0\u1dec\u1df9\u1e08\u1e0e\u1e17\u1e27\u1e2a\u1e35\u1e3a\u1e3e"+ + "\u1e42\u1e47\u1e4a\u1e50\u1e54\u1e56\u1e59\u1e60\u1e63\u1e6a\u1e72\u1e75"+ + "\u1e7e\u1e8d\u1e9a\u1ea5\u1ea8\u1eac\u1eb2\u1ec2\u1ecf\u1ed9\u1eeb\u1eed"+ + "\u1ef5\u1ef9\u1f03\u1f0d\u1f18\u1f1a\u1f23\u1f2d\u1f3b\u1f48\u1f4f\u1f58"+ + "\u1f67\u1f6b\u1f72\u1f75\u1f79\u1f7c\u1f89\u1f8d\u1f92\u1f9a\u1f9e\u1fa2"+ + "\u1fad\u1fb4\u1fba\u1fbe\u1fc0\u1fc4\u1fca\u1fd3\u1fd9\u1fdb\u1fdd\u1fe4"+ + "\u1fe8\u1ff1\u1ff5\u1fff\u2006\u200e\u2026\u202c\u2030\u2035\u203e\u2042"+ + "\u2045\u204a\u2057\u205d\u2065\u2068\u206f\u2074\u2089\u2092\u2097\u209d"+ + "\u20a2\u20a9\u20ae\u20b4\u20b6\u20ba\u20c1\u20c5\u20c8\u20cf\u20d4\u20d7"+ + "\u20de\u20e2\u20eb\u20ef\u20f7\u20f9\u2100\u2105\u2108\u2117\u2123\u212d"+ + "\u2136\u213b\u2140\u2147\u214a\u214e\u2155\u216d\u2176\u217c\u2180\u2185"+ + "\u218f\u2196\u219f\u21a2\u21ab\u21ad\u21b3\u21b7\u21bc\u21ca\u21cc\u21d2"+ + "\u21d8\u21db\u21e4\u21f6\u21fd\u2201\u2205\u2215\u221c\u2224\u2228\u222f"+ + "\u223c\u224c\u2252\u2258\u225f\u2264\u226a\u2271\u2279\u2281\u2286\u228a"+ + "\u2290\u2294\u2298\u229b\u22a1\u22a6\u22b6\u22b9\u22bb\u22c7\u22c9\u22cd"+ + "\u22d3\u22d8\u22e0\u22e5\u22e8\u22ef\u22f7\u22fd\u2300\u2309\u230e\u2315"+ + "\u231f\u2339\u2344\u2346\u2348\u2350\u2367\u236f\u2377\u2385\u238f\u2393"+ + "\u23a1\u23a8\u23af\u23b6\u23cf\u23ec\u2413\u2415\u2431\u2446\u244d\u245a"+ + "\u2466\u246c\u2475\u2486\u2492\u249b\u24a0\u24a7\u24b1\u24b4\u24bf\u24c5"+ + "\u24d4\u24dc\u24e5\u24ee\u24f1\u24f6\u24ff\u2504\u2512\u251c\u2524\u2532"+ + "\u2539\u2541\u2549\u2550\u2556\u255f\u2567\u2571\u257c\u2583\u25a0\u25a9"+ + "\u25b0\u25bb\u25c5\u25c9\u25cd\u25d2\u25da\u25de\u25e2\u25e7\u25ec\u25f1"+ + "\u25f8\u2600\u2603\u260a\u260f\u2616\u2626\u2635\u2643\u2648\u265b\u2660"+ + "\u2665\u266c\u2673\u267a\u2683\u2689\u268f\u2695\u269d\u26a5\u26df\u26ee"+ + "\u2705\u270d\u2711\u271d\u271f\u2726\u272f\u2741\u2749\u2752\u2759\u2763"+ + "\u2769\u2770\u2775\u277b\u277f\u2786\u27a4\u27b8\u27bc\u27cc\u27d3\u27e0"+ + "\u27e8\u27fc\u2802\u280e\u2813\u281d\u283d\u2842\u284b\u2850\u2854\u2859"+ + "\u2869\u287b\u287e\u2884\u28a0\u28aa\u28b1\u28b3\u28b8\u28c3\u28ce\u28e3"+ + "\u28ea\u28f1\u28f7\u28fa\u2905\u290c\u290e\u2917\u291e\u2924\u292a\u292e"+ + "\u293d\u294e\u2950\u2968\u296c\u2977\u297a\u297e\u2983\u2988\u2994\u299a"+ + "\u299e\u29a2\u29a6\u29ab\u29af\u29cb\u29d2\u29d8"; public static final String _serializedATN = Utils.join( new String[] { _serializedATNSegment0, _serializedATNSegment1, - _serializedATNSegment2 + _serializedATNSegment2, + _serializedATNSegment3, + _serializedATNSegment4 }, "" ); diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBase.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBase.java new file mode 100644 index 000000000..1801f2049 --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBase.java @@ -0,0 +1,123 @@ +/* +PostgreSQL grammar. +The MIT License (MIT). +Copyright (c) 2021-2023, Oleksii Kovalov (Oleksii.Kovalov@outlook.com). +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ +package org.springframework.ide.vscode.parser.postgresql; + +import java.util.List; +import org.antlr.v4.runtime.*; + +public abstract class PostgreSqlParserBase extends Parser { + + public PostgreSqlParserBase(TokenStream input) { + super(input); + } + + ParserRuleContext GetParsedSqlTree(String script, int line) { + PostgreSqlParser ph = getPostgreSqlParser(script); + ParserRuleContext result = ph.root(); + return result; + } + + public void ParseRoutineBody(PostgreSqlParser.Createfunc_opt_listContext _localctx) { + String lang = null; + for (PostgreSqlParser.Createfunc_opt_itemContext coi : _localctx.createfunc_opt_item()) { + if (coi.LANGUAGE() != null) { + if (coi.nonreservedword_or_sconst() != null) + if (coi.nonreservedword_or_sconst().nonreservedword() != null) + if (coi.nonreservedword_or_sconst().nonreservedword().identifier() != null) + if (coi.nonreservedword_or_sconst().nonreservedword().identifier() + .Identifier() != null) { + lang = coi.nonreservedword_or_sconst().nonreservedword().identifier() + .Identifier().getText(); + break; + } + } + } + if (null == lang) return; + PostgreSqlParser.Createfunc_opt_itemContext func_as = null; + for (PostgreSqlParser.Createfunc_opt_itemContext a : _localctx.createfunc_opt_item()) { + if (a.func_as() != null) { + func_as = a; + break; + + } + + } + if (func_as != null) { + String txt = GetRoutineBodyString(func_as.func_as().sconst(0)); + PostgreSqlParser ph = getPostgreSqlParser(txt); + switch (lang) { + case "plpgsql": + func_as.func_as().Definition = ph.plsqlroot(); + break; + case "sql": + func_as.func_as().Definition = ph.root(); + break; + } + } + } + + private String TrimQuotes(String s) { + return (s == null || s.isEmpty()) ? s : s.substring(1, s.length() - 1); + } + + public String unquote(String s) { + int slength = s.length(); + StringBuilder r = new StringBuilder(slength); + int i = 0; + while (i < slength) { + Character c = s.charAt(i); + r.append(c); + if (c == '\'' && i < slength - 1 && (s.charAt(i + 1) == '\'')) i++; + i++; + } + return r.toString(); + } + + public String GetRoutineBodyString(PostgreSqlParser.SconstContext rule) { + PostgreSqlParser.AnysconstContext anysconst = rule.anysconst(); + org.antlr.v4.runtime.tree.TerminalNode StringConstant = anysconst.StringConstant(); + if (null != StringConstant) return unquote(TrimQuotes(StringConstant.getText())); + org.antlr.v4.runtime.tree.TerminalNode UnicodeEscapeStringConstant = anysconst.UnicodeEscapeStringConstant(); + if (null != UnicodeEscapeStringConstant) return TrimQuotes(UnicodeEscapeStringConstant.getText()); + org.antlr.v4.runtime.tree.TerminalNode EscapeStringConstant = anysconst.EscapeStringConstant(); + if (null != EscapeStringConstant) return TrimQuotes(EscapeStringConstant.getText()); + String result = ""; + List dollartext = anysconst.DollarText(); + for (org.antlr.v4.runtime.tree.TerminalNode s : dollartext) { + result += s.getText(); + } + return result; + } + + public PostgreSqlParser getPostgreSqlParser(String script) { + CharStream charStream = CharStreams.fromString(script); + Lexer lexer = new PostgreSqlLexer(charStream); + CommonTokenStream tokens = new CommonTokenStream(lexer); + PostgreSqlParser parser = new PostgreSqlParser(tokens); + lexer.removeErrorListeners(); + parser.removeErrorListeners(); + LexerDispatchingErrorListener listener_lexer = new LexerDispatchingErrorListener((Lexer)(((CommonTokenStream)(this.getInputStream())).getTokenSource())); + ParserDispatchingErrorListener listener_parser = new ParserDispatchingErrorListener(this); + lexer.addErrorListener(listener_lexer); + parser.addErrorListener(listener_parser); + return parser; + } +} \ No newline at end of file diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBaseListener.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBaseListener.java index f41ee3bc7..20aa6a56f 100644 --- a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBaseListener.java +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBaseListener.java @@ -1,6 +1,8 @@ // Generated from PostgreSqlParser.g4 by ANTLR 4.13.1 package org.springframework.ide.vscode.parser.postgresql; + + import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.tree.ErrorNode; import org.antlr.v4.runtime.tree.TerminalNode; @@ -24,6 +26,42 @@ public class PostgreSqlParserBaseListener implements PostgreSqlParserListener { *

The default implementation does nothing.

*/ @Override public void exitRoot(PostgreSqlParser.RootContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPlsqlroot(PostgreSqlParser.PlsqlrootContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPlsqlroot(PostgreSqlParser.PlsqlrootContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmtblock(PostgreSqlParser.StmtblockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmtblock(PostgreSqlParser.StmtblockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmtmulti(PostgreSqlParser.StmtmultiContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmtmulti(PostgreSqlParser.StmtmultiContext ctx) { } /** * {@inheritDoc} * @@ -41,2149 +79,4693 @@ public class PostgreSqlParserBaseListener implements PostgreSqlParserListener { * *

The default implementation does nothing.

*/ - @Override public void enterAbort_stmt(PostgreSqlParser.Abort_stmtContext ctx) { } + @Override public void enterPlsqlconsolecommand(PostgreSqlParser.PlsqlconsolecommandContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAbort_stmt(PostgreSqlParser.Abort_stmtContext ctx) { } + @Override public void exitPlsqlconsolecommand(PostgreSqlParser.PlsqlconsolecommandContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_stmt(PostgreSqlParser.Alter_stmtContext ctx) { } + @Override public void enterCallstmt(PostgreSqlParser.CallstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_stmt(PostgreSqlParser.Alter_stmtContext ctx) { } + @Override public void exitCallstmt(PostgreSqlParser.CallstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_aggregate_stmt(PostgreSqlParser.Alter_aggregate_stmtContext ctx) { } + @Override public void enterCreaterolestmt(PostgreSqlParser.CreaterolestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_aggregate_stmt(PostgreSqlParser.Alter_aggregate_stmtContext ctx) { } + @Override public void exitCreaterolestmt(PostgreSqlParser.CreaterolestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_collation_stmt(PostgreSqlParser.Alter_collation_stmtContext ctx) { } + @Override public void enterOpt_with(PostgreSqlParser.Opt_withContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_collation_stmt(PostgreSqlParser.Alter_collation_stmtContext ctx) { } + @Override public void exitOpt_with(PostgreSqlParser.Opt_withContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_conversion_stmt(PostgreSqlParser.Alter_conversion_stmtContext ctx) { } + @Override public void enterOptrolelist(PostgreSqlParser.OptrolelistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_conversion_stmt(PostgreSqlParser.Alter_conversion_stmtContext ctx) { } + @Override public void exitOptrolelist(PostgreSqlParser.OptrolelistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_database_stmt(PostgreSqlParser.Alter_database_stmtContext ctx) { } + @Override public void enterAlteroptrolelist(PostgreSqlParser.AlteroptrolelistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_database_stmt(PostgreSqlParser.Alter_database_stmtContext ctx) { } + @Override public void exitAlteroptrolelist(PostgreSqlParser.AlteroptrolelistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_default_privileges_stmt(PostgreSqlParser.Alter_default_privileges_stmtContext ctx) { } + @Override public void enterAlteroptroleelem(PostgreSqlParser.AlteroptroleelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_default_privileges_stmt(PostgreSqlParser.Alter_default_privileges_stmtContext ctx) { } + @Override public void exitAlteroptroleelem(PostgreSqlParser.AlteroptroleelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_domain_stmt(PostgreSqlParser.Alter_domain_stmtContext ctx) { } + @Override public void enterCreateoptroleelem(PostgreSqlParser.CreateoptroleelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_domain_stmt(PostgreSqlParser.Alter_domain_stmtContext ctx) { } + @Override public void exitCreateoptroleelem(PostgreSqlParser.CreateoptroleelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_event_trigger_stmt(PostgreSqlParser.Alter_event_trigger_stmtContext ctx) { } + @Override public void enterCreateuserstmt(PostgreSqlParser.CreateuserstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_event_trigger_stmt(PostgreSqlParser.Alter_event_trigger_stmtContext ctx) { } + @Override public void exitCreateuserstmt(PostgreSqlParser.CreateuserstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_extension_stmt(PostgreSqlParser.Alter_extension_stmtContext ctx) { } + @Override public void enterAlterrolestmt(PostgreSqlParser.AlterrolestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_extension_stmt(PostgreSqlParser.Alter_extension_stmtContext ctx) { } + @Override public void exitAlterrolestmt(PostgreSqlParser.AlterrolestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_foreign_data_wrapper_stmt(PostgreSqlParser.Alter_foreign_data_wrapper_stmtContext ctx) { } + @Override public void enterOpt_in_database(PostgreSqlParser.Opt_in_databaseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_foreign_data_wrapper_stmt(PostgreSqlParser.Alter_foreign_data_wrapper_stmtContext ctx) { } + @Override public void exitOpt_in_database(PostgreSqlParser.Opt_in_databaseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_foreign_table_action(PostgreSqlParser.Alter_foreign_table_actionContext ctx) { } + @Override public void enterAlterrolesetstmt(PostgreSqlParser.AlterrolesetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_foreign_table_action(PostgreSqlParser.Alter_foreign_table_actionContext ctx) { } + @Override public void exitAlterrolesetstmt(PostgreSqlParser.AlterrolesetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_foreign_table_action_list(PostgreSqlParser.Alter_foreign_table_action_listContext ctx) { } + @Override public void enterDroprolestmt(PostgreSqlParser.DroprolestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_foreign_table_action_list(PostgreSqlParser.Alter_foreign_table_action_listContext ctx) { } + @Override public void exitDroprolestmt(PostgreSqlParser.DroprolestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_foreign_table_stmt(PostgreSqlParser.Alter_foreign_table_stmtContext ctx) { } + @Override public void enterCreategroupstmt(PostgreSqlParser.CreategroupstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_foreign_table_stmt(PostgreSqlParser.Alter_foreign_table_stmtContext ctx) { } + @Override public void exitCreategroupstmt(PostgreSqlParser.CreategroupstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_function_stmt(PostgreSqlParser.Alter_function_stmtContext ctx) { } + @Override public void enterAltergroupstmt(PostgreSqlParser.AltergroupstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_function_stmt(PostgreSqlParser.Alter_function_stmtContext ctx) { } + @Override public void exitAltergroupstmt(PostgreSqlParser.AltergroupstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_group_stmt(PostgreSqlParser.Alter_group_stmtContext ctx) { } + @Override public void enterAdd_drop(PostgreSqlParser.Add_dropContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_group_stmt(PostgreSqlParser.Alter_group_stmtContext ctx) { } + @Override public void exitAdd_drop(PostgreSqlParser.Add_dropContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_index_stmt(PostgreSqlParser.Alter_index_stmtContext ctx) { } + @Override public void enterCreateschemastmt(PostgreSqlParser.CreateschemastmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_index_stmt(PostgreSqlParser.Alter_index_stmtContext ctx) { } + @Override public void exitCreateschemastmt(PostgreSqlParser.CreateschemastmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_language_stmt(PostgreSqlParser.Alter_language_stmtContext ctx) { } + @Override public void enterOptschemaname(PostgreSqlParser.OptschemanameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_language_stmt(PostgreSqlParser.Alter_language_stmtContext ctx) { } + @Override public void exitOptschemaname(PostgreSqlParser.OptschemanameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_large_object_stmt(PostgreSqlParser.Alter_large_object_stmtContext ctx) { } + @Override public void enterOptschemaeltlist(PostgreSqlParser.OptschemaeltlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_large_object_stmt(PostgreSqlParser.Alter_large_object_stmtContext ctx) { } + @Override public void exitOptschemaeltlist(PostgreSqlParser.OptschemaeltlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_materialize_view_stmt(PostgreSqlParser.Alter_materialize_view_stmtContext ctx) { } + @Override public void enterSchema_stmt(PostgreSqlParser.Schema_stmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_materialize_view_stmt(PostgreSqlParser.Alter_materialize_view_stmtContext ctx) { } + @Override public void exitSchema_stmt(PostgreSqlParser.Schema_stmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_operator_stmt(PostgreSqlParser.Alter_operator_stmtContext ctx) { } + @Override public void enterVariablesetstmt(PostgreSqlParser.VariablesetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_operator_stmt(PostgreSqlParser.Alter_operator_stmtContext ctx) { } + @Override public void exitVariablesetstmt(PostgreSqlParser.VariablesetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_operator_class_stmt(PostgreSqlParser.Alter_operator_class_stmtContext ctx) { } + @Override public void enterSet_rest(PostgreSqlParser.Set_restContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_operator_class_stmt(PostgreSqlParser.Alter_operator_class_stmtContext ctx) { } + @Override public void exitSet_rest(PostgreSqlParser.Set_restContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_operator_family_stmt(PostgreSqlParser.Alter_operator_family_stmtContext ctx) { } + @Override public void enterGeneric_set(PostgreSqlParser.Generic_setContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_operator_family_stmt(PostgreSqlParser.Alter_operator_family_stmtContext ctx) { } + @Override public void exitGeneric_set(PostgreSqlParser.Generic_setContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_policy_stmt(PostgreSqlParser.Alter_policy_stmtContext ctx) { } + @Override public void enterSet_rest_more(PostgreSqlParser.Set_rest_moreContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_policy_stmt(PostgreSqlParser.Alter_policy_stmtContext ctx) { } + @Override public void exitSet_rest_more(PostgreSqlParser.Set_rest_moreContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_publication_stmt(PostgreSqlParser.Alter_publication_stmtContext ctx) { } + @Override public void enterVar_name(PostgreSqlParser.Var_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_publication_stmt(PostgreSqlParser.Alter_publication_stmtContext ctx) { } + @Override public void exitVar_name(PostgreSqlParser.Var_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_role_options(PostgreSqlParser.Alter_role_optionsContext ctx) { } + @Override public void enterVar_list(PostgreSqlParser.Var_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_role_options(PostgreSqlParser.Alter_role_optionsContext ctx) { } + @Override public void exitVar_list(PostgreSqlParser.Var_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_role_stmt(PostgreSqlParser.Alter_role_stmtContext ctx) { } + @Override public void enterVar_value(PostgreSqlParser.Var_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_role_stmt(PostgreSqlParser.Alter_role_stmtContext ctx) { } + @Override public void exitVar_value(PostgreSqlParser.Var_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_rule_stmt(PostgreSqlParser.Alter_rule_stmtContext ctx) { } + @Override public void enterIso_level(PostgreSqlParser.Iso_levelContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_rule_stmt(PostgreSqlParser.Alter_rule_stmtContext ctx) { } + @Override public void exitIso_level(PostgreSqlParser.Iso_levelContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_schema_stmt(PostgreSqlParser.Alter_schema_stmtContext ctx) { } + @Override public void enterOpt_boolean_or_string(PostgreSqlParser.Opt_boolean_or_stringContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_schema_stmt(PostgreSqlParser.Alter_schema_stmtContext ctx) { } + @Override public void exitOpt_boolean_or_string(PostgreSqlParser.Opt_boolean_or_stringContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_sequence_stmt(PostgreSqlParser.Alter_sequence_stmtContext ctx) { } + @Override public void enterZone_value(PostgreSqlParser.Zone_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_sequence_stmt(PostgreSqlParser.Alter_sequence_stmtContext ctx) { } + @Override public void exitZone_value(PostgreSqlParser.Zone_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_server_options_list(PostgreSqlParser.Alter_server_options_listContext ctx) { } + @Override public void enterOpt_encoding(PostgreSqlParser.Opt_encodingContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_server_options_list(PostgreSqlParser.Alter_server_options_listContext ctx) { } + @Override public void exitOpt_encoding(PostgreSqlParser.Opt_encodingContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_server_stmt(PostgreSqlParser.Alter_server_stmtContext ctx) { } + @Override public void enterNonreservedword_or_sconst(PostgreSqlParser.Nonreservedword_or_sconstContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_server_stmt(PostgreSqlParser.Alter_server_stmtContext ctx) { } + @Override public void exitNonreservedword_or_sconst(PostgreSqlParser.Nonreservedword_or_sconstContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_statistics_stmt(PostgreSqlParser.Alter_statistics_stmtContext ctx) { } + @Override public void enterVariableresetstmt(PostgreSqlParser.VariableresetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_statistics_stmt(PostgreSqlParser.Alter_statistics_stmtContext ctx) { } + @Override public void exitVariableresetstmt(PostgreSqlParser.VariableresetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_subscription_stmt(PostgreSqlParser.Alter_subscription_stmtContext ctx) { } + @Override public void enterReset_rest(PostgreSqlParser.Reset_restContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_subscription_stmt(PostgreSqlParser.Alter_subscription_stmtContext ctx) { } + @Override public void exitReset_rest(PostgreSqlParser.Reset_restContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_system_stmt(PostgreSqlParser.Alter_system_stmtContext ctx) { } + @Override public void enterGeneric_reset(PostgreSqlParser.Generic_resetContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_system_stmt(PostgreSqlParser.Alter_system_stmtContext ctx) { } + @Override public void exitGeneric_reset(PostgreSqlParser.Generic_resetContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_table_stmt(PostgreSqlParser.Alter_table_stmtContext ctx) { } + @Override public void enterSetresetclause(PostgreSqlParser.SetresetclauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_table_stmt(PostgreSqlParser.Alter_table_stmtContext ctx) { } + @Override public void exitSetresetclause(PostgreSqlParser.SetresetclauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_tablespace_stmt(PostgreSqlParser.Alter_tablespace_stmtContext ctx) { } + @Override public void enterFunctionsetresetclause(PostgreSqlParser.FunctionsetresetclauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_tablespace_stmt(PostgreSqlParser.Alter_tablespace_stmtContext ctx) { } + @Override public void exitFunctionsetresetclause(PostgreSqlParser.FunctionsetresetclauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_text_search_config_stmt(PostgreSqlParser.Alter_text_search_config_stmtContext ctx) { } + @Override public void enterVariableshowstmt(PostgreSqlParser.VariableshowstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_text_search_config_stmt(PostgreSqlParser.Alter_text_search_config_stmtContext ctx) { } + @Override public void exitVariableshowstmt(PostgreSqlParser.VariableshowstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_text_search_dict_stmt(PostgreSqlParser.Alter_text_search_dict_stmtContext ctx) { } + @Override public void enterConstraintssetstmt(PostgreSqlParser.ConstraintssetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_text_search_dict_stmt(PostgreSqlParser.Alter_text_search_dict_stmtContext ctx) { } + @Override public void exitConstraintssetstmt(PostgreSqlParser.ConstraintssetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_text_search_parser_stmt(PostgreSqlParser.Alter_text_search_parser_stmtContext ctx) { } + @Override public void enterConstraints_set_list(PostgreSqlParser.Constraints_set_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_text_search_parser_stmt(PostgreSqlParser.Alter_text_search_parser_stmtContext ctx) { } + @Override public void exitConstraints_set_list(PostgreSqlParser.Constraints_set_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_text_search_template_stmt(PostgreSqlParser.Alter_text_search_template_stmtContext ctx) { } + @Override public void enterConstraints_set_mode(PostgreSqlParser.Constraints_set_modeContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_text_search_template_stmt(PostgreSqlParser.Alter_text_search_template_stmtContext ctx) { } + @Override public void exitConstraints_set_mode(PostgreSqlParser.Constraints_set_modeContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_trigger_stmt(PostgreSqlParser.Alter_trigger_stmtContext ctx) { } + @Override public void enterCheckpointstmt(PostgreSqlParser.CheckpointstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_trigger_stmt(PostgreSqlParser.Alter_trigger_stmtContext ctx) { } + @Override public void exitCheckpointstmt(PostgreSqlParser.CheckpointstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_type_stmt(PostgreSqlParser.Alter_type_stmtContext ctx) { } + @Override public void enterDiscardstmt(PostgreSqlParser.DiscardstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_type_stmt(PostgreSqlParser.Alter_type_stmtContext ctx) { } + @Override public void exitDiscardstmt(PostgreSqlParser.DiscardstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_user_stmt(PostgreSqlParser.Alter_user_stmtContext ctx) { } + @Override public void enterAltertablestmt(PostgreSqlParser.AltertablestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_user_stmt(PostgreSqlParser.Alter_user_stmtContext ctx) { } + @Override public void exitAltertablestmt(PostgreSqlParser.AltertablestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_user_mapping_stmt(PostgreSqlParser.Alter_user_mapping_stmtContext ctx) { } + @Override public void enterAlter_table_cmds(PostgreSqlParser.Alter_table_cmdsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_user_mapping_stmt(PostgreSqlParser.Alter_user_mapping_stmtContext ctx) { } + @Override public void exitAlter_table_cmds(PostgreSqlParser.Alter_table_cmdsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlter_view_stmt(PostgreSqlParser.Alter_view_stmtContext ctx) { } + @Override public void enterPartition_cmd(PostgreSqlParser.Partition_cmdContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlter_view_stmt(PostgreSqlParser.Alter_view_stmtContext ctx) { } + @Override public void exitPartition_cmd(PostgreSqlParser.Partition_cmdContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAnalyze_stmt(PostgreSqlParser.Analyze_stmtContext ctx) { } + @Override public void enterIndex_partition_cmd(PostgreSqlParser.Index_partition_cmdContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAnalyze_stmt(PostgreSqlParser.Analyze_stmtContext ctx) { } + @Override public void exitIndex_partition_cmd(PostgreSqlParser.Index_partition_cmdContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterClose_stmt(PostgreSqlParser.Close_stmtContext ctx) { } + @Override public void enterAlter_table_cmd(PostgreSqlParser.Alter_table_cmdContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitClose_stmt(PostgreSqlParser.Close_stmtContext ctx) { } + @Override public void exitAlter_table_cmd(PostgreSqlParser.Alter_table_cmdContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCluster_stmt(PostgreSqlParser.Cluster_stmtContext ctx) { } + @Override public void enterAlter_column_default(PostgreSqlParser.Alter_column_defaultContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCluster_stmt(PostgreSqlParser.Cluster_stmtContext ctx) { } + @Override public void exitAlter_column_default(PostgreSqlParser.Alter_column_defaultContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterComment_stmt(PostgreSqlParser.Comment_stmtContext ctx) { } + @Override public void enterOpt_drop_behavior(PostgreSqlParser.Opt_drop_behaviorContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitComment_stmt(PostgreSqlParser.Comment_stmtContext ctx) { } + @Override public void exitOpt_drop_behavior(PostgreSqlParser.Opt_drop_behaviorContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCommit_stmt(PostgreSqlParser.Commit_stmtContext ctx) { } + @Override public void enterOpt_collate_clause(PostgreSqlParser.Opt_collate_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCommit_stmt(PostgreSqlParser.Commit_stmtContext ctx) { } + @Override public void exitOpt_collate_clause(PostgreSqlParser.Opt_collate_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCommit_prepared_stmt(PostgreSqlParser.Commit_prepared_stmtContext ctx) { } + @Override public void enterAlter_using(PostgreSqlParser.Alter_usingContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCommit_prepared_stmt(PostgreSqlParser.Commit_prepared_stmtContext ctx) { } + @Override public void exitAlter_using(PostgreSqlParser.Alter_usingContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCopy_stmt(PostgreSqlParser.Copy_stmtContext ctx) { } + @Override public void enterReplica_identity(PostgreSqlParser.Replica_identityContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCopy_stmt(PostgreSqlParser.Copy_stmtContext ctx) { } + @Override public void exitReplica_identity(PostgreSqlParser.Replica_identityContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_stmt(PostgreSqlParser.Create_stmtContext ctx) { } + @Override public void enterReloptions(PostgreSqlParser.ReloptionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_stmt(PostgreSqlParser.Create_stmtContext ctx) { } + @Override public void exitReloptions(PostgreSqlParser.ReloptionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_access_method_stmt(PostgreSqlParser.Create_access_method_stmtContext ctx) { } + @Override public void enterOpt_reloptions(PostgreSqlParser.Opt_reloptionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_access_method_stmt(PostgreSqlParser.Create_access_method_stmtContext ctx) { } + @Override public void exitOpt_reloptions(PostgreSqlParser.Opt_reloptionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_aggregate_stmt(PostgreSqlParser.Create_aggregate_stmtContext ctx) { } + @Override public void enterReloption_list(PostgreSqlParser.Reloption_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_aggregate_stmt(PostgreSqlParser.Create_aggregate_stmtContext ctx) { } + @Override public void exitReloption_list(PostgreSqlParser.Reloption_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_cast_stmt(PostgreSqlParser.Create_cast_stmtContext ctx) { } + @Override public void enterReloption_elem(PostgreSqlParser.Reloption_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_cast_stmt(PostgreSqlParser.Create_cast_stmtContext ctx) { } + @Override public void exitReloption_elem(PostgreSqlParser.Reloption_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_collation_opt(PostgreSqlParser.Create_collation_optContext ctx) { } + @Override public void enterAlter_identity_column_option_list(PostgreSqlParser.Alter_identity_column_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_collation_opt(PostgreSqlParser.Create_collation_optContext ctx) { } + @Override public void exitAlter_identity_column_option_list(PostgreSqlParser.Alter_identity_column_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_collation_opt_list(PostgreSqlParser.Create_collation_opt_listContext ctx) { } + @Override public void enterAlter_identity_column_option(PostgreSqlParser.Alter_identity_column_optionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_collation_opt_list(PostgreSqlParser.Create_collation_opt_listContext ctx) { } + @Override public void exitAlter_identity_column_option(PostgreSqlParser.Alter_identity_column_optionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_collation_stmt(PostgreSqlParser.Create_collation_stmtContext ctx) { } + @Override public void enterPartitionboundspec(PostgreSqlParser.PartitionboundspecContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_collation_stmt(PostgreSqlParser.Create_collation_stmtContext ctx) { } + @Override public void exitPartitionboundspec(PostgreSqlParser.PartitionboundspecContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_conversion_stmt(PostgreSqlParser.Create_conversion_stmtContext ctx) { } + @Override public void enterHash_partbound_elem(PostgreSqlParser.Hash_partbound_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_conversion_stmt(PostgreSqlParser.Create_conversion_stmtContext ctx) { } + @Override public void exitHash_partbound_elem(PostgreSqlParser.Hash_partbound_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_database_stmt(PostgreSqlParser.Create_database_stmtContext ctx) { } + @Override public void enterHash_partbound(PostgreSqlParser.Hash_partboundContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_database_stmt(PostgreSqlParser.Create_database_stmtContext ctx) { } + @Override public void exitHash_partbound(PostgreSqlParser.Hash_partboundContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDomain_constraint(PostgreSqlParser.Domain_constraintContext ctx) { } + @Override public void enterAltercompositetypestmt(PostgreSqlParser.AltercompositetypestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDomain_constraint(PostgreSqlParser.Domain_constraintContext ctx) { } + @Override public void exitAltercompositetypestmt(PostgreSqlParser.AltercompositetypestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_domain_stmt(PostgreSqlParser.Create_domain_stmtContext ctx) { } + @Override public void enterAlter_type_cmds(PostgreSqlParser.Alter_type_cmdsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_domain_stmt(PostgreSqlParser.Create_domain_stmtContext ctx) { } + @Override public void exitAlter_type_cmds(PostgreSqlParser.Alter_type_cmdsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_event_trigger_cond(PostgreSqlParser.Create_event_trigger_condContext ctx) { } + @Override public void enterAlter_type_cmd(PostgreSqlParser.Alter_type_cmdContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_event_trigger_cond(PostgreSqlParser.Create_event_trigger_condContext ctx) { } + @Override public void exitAlter_type_cmd(PostgreSqlParser.Alter_type_cmdContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_event_trigger_stmt(PostgreSqlParser.Create_event_trigger_stmtContext ctx) { } + @Override public void enterCloseportalstmt(PostgreSqlParser.CloseportalstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_event_trigger_stmt(PostgreSqlParser.Create_event_trigger_stmtContext ctx) { } + @Override public void exitCloseportalstmt(PostgreSqlParser.CloseportalstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_foreign_data_options(PostgreSqlParser.Create_foreign_data_optionsContext ctx) { } + @Override public void enterCopystmt(PostgreSqlParser.CopystmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_foreign_data_options(PostgreSqlParser.Create_foreign_data_optionsContext ctx) { } + @Override public void exitCopystmt(PostgreSqlParser.CopystmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_foreign_data_stmt(PostgreSqlParser.Create_foreign_data_stmtContext ctx) { } + @Override public void enterCopy_from(PostgreSqlParser.Copy_fromContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_foreign_data_stmt(PostgreSqlParser.Create_foreign_data_stmtContext ctx) { } + @Override public void exitCopy_from(PostgreSqlParser.Copy_fromContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_foreign_table_stmt(PostgreSqlParser.Create_foreign_table_stmtContext ctx) { } + @Override public void enterOpt_program(PostgreSqlParser.Opt_programContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_foreign_table_stmt(PostgreSqlParser.Create_foreign_table_stmtContext ctx) { } + @Override public void exitOpt_program(PostgreSqlParser.Opt_programContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_function_stmt(PostgreSqlParser.Create_function_stmtContext ctx) { } + @Override public void enterCopy_file_name(PostgreSqlParser.Copy_file_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_function_stmt(PostgreSqlParser.Create_function_stmtContext ctx) { } + @Override public void exitCopy_file_name(PostgreSqlParser.Copy_file_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_group_stmt(PostgreSqlParser.Create_group_stmtContext ctx) { } + @Override public void enterCopy_options(PostgreSqlParser.Copy_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_group_stmt(PostgreSqlParser.Create_group_stmtContext ctx) { } + @Override public void exitCopy_options(PostgreSqlParser.Copy_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_index_stmt(PostgreSqlParser.Create_index_stmtContext ctx) { } + @Override public void enterCopy_opt_list(PostgreSqlParser.Copy_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_index_stmt(PostgreSqlParser.Create_index_stmtContext ctx) { } + @Override public void exitCopy_opt_list(PostgreSqlParser.Copy_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_language_stmt(PostgreSqlParser.Create_language_stmtContext ctx) { } + @Override public void enterCopy_opt_item(PostgreSqlParser.Copy_opt_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_language_stmt(PostgreSqlParser.Create_language_stmtContext ctx) { } + @Override public void exitCopy_opt_item(PostgreSqlParser.Copy_opt_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_materialized_view_stmt(PostgreSqlParser.Create_materialized_view_stmtContext ctx) { } + @Override public void enterOpt_binary(PostgreSqlParser.Opt_binaryContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_materialized_view_stmt(PostgreSqlParser.Create_materialized_view_stmtContext ctx) { } + @Override public void exitOpt_binary(PostgreSqlParser.Opt_binaryContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_operator_stmt(PostgreSqlParser.Create_operator_stmtContext ctx) { } + @Override public void enterCopy_delimiter(PostgreSqlParser.Copy_delimiterContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_operator_stmt(PostgreSqlParser.Create_operator_stmtContext ctx) { } + @Override public void exitCopy_delimiter(PostgreSqlParser.Copy_delimiterContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_operator_class_opt(PostgreSqlParser.Create_operator_class_optContext ctx) { } + @Override public void enterOpt_using(PostgreSqlParser.Opt_usingContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_operator_class_opt(PostgreSqlParser.Create_operator_class_optContext ctx) { } + @Override public void exitOpt_using(PostgreSqlParser.Opt_usingContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_operator_class_stmt(PostgreSqlParser.Create_operator_class_stmtContext ctx) { } + @Override public void enterCopy_generic_opt_list(PostgreSqlParser.Copy_generic_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_operator_class_stmt(PostgreSqlParser.Create_operator_class_stmtContext ctx) { } + @Override public void exitCopy_generic_opt_list(PostgreSqlParser.Copy_generic_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_operator_family_stmt(PostgreSqlParser.Create_operator_family_stmtContext ctx) { } + @Override public void enterCopy_generic_opt_elem(PostgreSqlParser.Copy_generic_opt_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_operator_family_stmt(PostgreSqlParser.Create_operator_family_stmtContext ctx) { } + @Override public void exitCopy_generic_opt_elem(PostgreSqlParser.Copy_generic_opt_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_policy_stmt(PostgreSqlParser.Create_policy_stmtContext ctx) { } + @Override public void enterCopy_generic_opt_arg(PostgreSqlParser.Copy_generic_opt_argContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_policy_stmt(PostgreSqlParser.Create_policy_stmtContext ctx) { } + @Override public void exitCopy_generic_opt_arg(PostgreSqlParser.Copy_generic_opt_argContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_role_stmt(PostgreSqlParser.Create_role_stmtContext ctx) { } + @Override public void enterCopy_generic_opt_arg_list(PostgreSqlParser.Copy_generic_opt_arg_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_role_stmt(PostgreSqlParser.Create_role_stmtContext ctx) { } + @Override public void exitCopy_generic_opt_arg_list(PostgreSqlParser.Copy_generic_opt_arg_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_rule_event(PostgreSqlParser.Create_rule_eventContext ctx) { } + @Override public void enterCopy_generic_opt_arg_list_item(PostgreSqlParser.Copy_generic_opt_arg_list_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_rule_event(PostgreSqlParser.Create_rule_eventContext ctx) { } + @Override public void exitCopy_generic_opt_arg_list_item(PostgreSqlParser.Copy_generic_opt_arg_list_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_rule_stmt(PostgreSqlParser.Create_rule_stmtContext ctx) { } + @Override public void enterCreatestmt(PostgreSqlParser.CreatestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_rule_stmt(PostgreSqlParser.Create_rule_stmtContext ctx) { } + @Override public void exitCreatestmt(PostgreSqlParser.CreatestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_schema_stmt(PostgreSqlParser.Create_schema_stmtContext ctx) { } + @Override public void enterOpttemp(PostgreSqlParser.OpttempContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_schema_stmt(PostgreSqlParser.Create_schema_stmtContext ctx) { } + @Override public void exitOpttemp(PostgreSqlParser.OpttempContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_sequence_stmt(PostgreSqlParser.Create_sequence_stmtContext ctx) { } + @Override public void enterOpttableelementlist(PostgreSqlParser.OpttableelementlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_sequence_stmt(PostgreSqlParser.Create_sequence_stmtContext ctx) { } + @Override public void exitOpttableelementlist(PostgreSqlParser.OpttableelementlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_server_stmt(PostgreSqlParser.Create_server_stmtContext ctx) { } + @Override public void enterOpttypedtableelementlist(PostgreSqlParser.OpttypedtableelementlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_server_stmt(PostgreSqlParser.Create_server_stmtContext ctx) { } + @Override public void exitOpttypedtableelementlist(PostgreSqlParser.OpttypedtableelementlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_statistics_stmt(PostgreSqlParser.Create_statistics_stmtContext ctx) { } + @Override public void enterTableelementlist(PostgreSqlParser.TableelementlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_statistics_stmt(PostgreSqlParser.Create_statistics_stmtContext ctx) { } + @Override public void exitTableelementlist(PostgreSqlParser.TableelementlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_subscription_stmt(PostgreSqlParser.Create_subscription_stmtContext ctx) { } + @Override public void enterTypedtableelementlist(PostgreSqlParser.TypedtableelementlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_subscription_stmt(PostgreSqlParser.Create_subscription_stmtContext ctx) { } + @Override public void exitTypedtableelementlist(PostgreSqlParser.TypedtableelementlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_table_stmt(PostgreSqlParser.Create_table_stmtContext ctx) { } + @Override public void enterTableelement(PostgreSqlParser.TableelementContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_table_stmt(PostgreSqlParser.Create_table_stmtContext ctx) { } + @Override public void exitTableelement(PostgreSqlParser.TableelementContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_table_as_stmt(PostgreSqlParser.Create_table_as_stmtContext ctx) { } + @Override public void enterTypedtableelement(PostgreSqlParser.TypedtableelementContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_table_as_stmt(PostgreSqlParser.Create_table_as_stmtContext ctx) { } + @Override public void exitTypedtableelement(PostgreSqlParser.TypedtableelementContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_tablespace_stmt(PostgreSqlParser.Create_tablespace_stmtContext ctx) { } + @Override public void enterColumnDef(PostgreSqlParser.ColumnDefContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_tablespace_stmt(PostgreSqlParser.Create_tablespace_stmtContext ctx) { } + @Override public void exitColumnDef(PostgreSqlParser.ColumnDefContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_text_search_config_stmt(PostgreSqlParser.Create_text_search_config_stmtContext ctx) { } + @Override public void enterColumnOptions(PostgreSqlParser.ColumnOptionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_text_search_config_stmt(PostgreSqlParser.Create_text_search_config_stmtContext ctx) { } + @Override public void exitColumnOptions(PostgreSqlParser.ColumnOptionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_text_search_dict_stmt(PostgreSqlParser.Create_text_search_dict_stmtContext ctx) { } + @Override public void enterColquallist(PostgreSqlParser.ColquallistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_text_search_dict_stmt(PostgreSqlParser.Create_text_search_dict_stmtContext ctx) { } + @Override public void exitColquallist(PostgreSqlParser.ColquallistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_text_search_parser_stmt(PostgreSqlParser.Create_text_search_parser_stmtContext ctx) { } + @Override public void enterColconstraint(PostgreSqlParser.ColconstraintContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_text_search_parser_stmt(PostgreSqlParser.Create_text_search_parser_stmtContext ctx) { } + @Override public void exitColconstraint(PostgreSqlParser.ColconstraintContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_text_search_template_stmt(PostgreSqlParser.Create_text_search_template_stmtContext ctx) { } + @Override public void enterColconstraintelem(PostgreSqlParser.ColconstraintelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_text_search_template_stmt(PostgreSqlParser.Create_text_search_template_stmtContext ctx) { } + @Override public void exitColconstraintelem(PostgreSqlParser.ColconstraintelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_transform_stmt(PostgreSqlParser.Create_transform_stmtContext ctx) { } + @Override public void enterGenerated_when(PostgreSqlParser.Generated_whenContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_transform_stmt(PostgreSqlParser.Create_transform_stmtContext ctx) { } + @Override public void exitGenerated_when(PostgreSqlParser.Generated_whenContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_trigger_stmt(PostgreSqlParser.Create_trigger_stmtContext ctx) { } + @Override public void enterConstraintattr(PostgreSqlParser.ConstraintattrContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_trigger_stmt(PostgreSqlParser.Create_trigger_stmtContext ctx) { } + @Override public void exitConstraintattr(PostgreSqlParser.ConstraintattrContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_type_stmt(PostgreSqlParser.Create_type_stmtContext ctx) { } + @Override public void enterTablelikeclause(PostgreSqlParser.TablelikeclauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_type_stmt(PostgreSqlParser.Create_type_stmtContext ctx) { } + @Override public void exitTablelikeclause(PostgreSqlParser.TablelikeclauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_user_stmt(PostgreSqlParser.Create_user_stmtContext ctx) { } + @Override public void enterTablelikeoptionlist(PostgreSqlParser.TablelikeoptionlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_user_stmt(PostgreSqlParser.Create_user_stmtContext ctx) { } + @Override public void exitTablelikeoptionlist(PostgreSqlParser.TablelikeoptionlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_user_mapping_stmt(PostgreSqlParser.Create_user_mapping_stmtContext ctx) { } + @Override public void enterTablelikeoption(PostgreSqlParser.TablelikeoptionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_user_mapping_stmt(PostgreSqlParser.Create_user_mapping_stmtContext ctx) { } + @Override public void exitTablelikeoption(PostgreSqlParser.TablelikeoptionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCreate_view_stmt(PostgreSqlParser.Create_view_stmtContext ctx) { } + @Override public void enterTableconstraint(PostgreSqlParser.TableconstraintContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCreate_view_stmt(PostgreSqlParser.Create_view_stmtContext ctx) { } + @Override public void exitTableconstraint(PostgreSqlParser.TableconstraintContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDeallocate_stmt(PostgreSqlParser.Deallocate_stmtContext ctx) { } + @Override public void enterConstraintelem(PostgreSqlParser.ConstraintelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDeallocate_stmt(PostgreSqlParser.Deallocate_stmtContext ctx) { } + @Override public void exitConstraintelem(PostgreSqlParser.ConstraintelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDeclare_stmt(PostgreSqlParser.Declare_stmtContext ctx) { } + @Override public void enterOpt_no_inherit(PostgreSqlParser.Opt_no_inheritContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDeclare_stmt(PostgreSqlParser.Declare_stmtContext ctx) { } + @Override public void exitOpt_no_inherit(PostgreSqlParser.Opt_no_inheritContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDelete_stmt(PostgreSqlParser.Delete_stmtContext ctx) { } + @Override public void enterOpt_column_list(PostgreSqlParser.Opt_column_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDelete_stmt(PostgreSqlParser.Delete_stmtContext ctx) { } + @Override public void exitOpt_column_list(PostgreSqlParser.Opt_column_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDiscard_stmt(PostgreSqlParser.Discard_stmtContext ctx) { } + @Override public void enterColumnlist(PostgreSqlParser.ColumnlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDiscard_stmt(PostgreSqlParser.Discard_stmtContext ctx) { } + @Override public void exitColumnlist(PostgreSqlParser.ColumnlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_stmt(PostgreSqlParser.Drop_stmtContext ctx) { } + @Override public void enterColumnElem(PostgreSqlParser.ColumnElemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_stmt(PostgreSqlParser.Drop_stmtContext ctx) { } + @Override public void exitColumnElem(PostgreSqlParser.ColumnElemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_access_method_stmt(PostgreSqlParser.Drop_access_method_stmtContext ctx) { } + @Override public void enterOpt_c_include(PostgreSqlParser.Opt_c_includeContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_access_method_stmt(PostgreSqlParser.Drop_access_method_stmtContext ctx) { } + @Override public void exitOpt_c_include(PostgreSqlParser.Opt_c_includeContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_aggregate_stmt(PostgreSqlParser.Drop_aggregate_stmtContext ctx) { } + @Override public void enterKey_match(PostgreSqlParser.Key_matchContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_aggregate_stmt(PostgreSqlParser.Drop_aggregate_stmtContext ctx) { } + @Override public void exitKey_match(PostgreSqlParser.Key_matchContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_cast_stmt(PostgreSqlParser.Drop_cast_stmtContext ctx) { } + @Override public void enterExclusionconstraintlist(PostgreSqlParser.ExclusionconstraintlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_cast_stmt(PostgreSqlParser.Drop_cast_stmtContext ctx) { } + @Override public void exitExclusionconstraintlist(PostgreSqlParser.ExclusionconstraintlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_collation_stmt(PostgreSqlParser.Drop_collation_stmtContext ctx) { } + @Override public void enterExclusionconstraintelem(PostgreSqlParser.ExclusionconstraintelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_collation_stmt(PostgreSqlParser.Drop_collation_stmtContext ctx) { } + @Override public void exitExclusionconstraintelem(PostgreSqlParser.ExclusionconstraintelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_conversion_stmt(PostgreSqlParser.Drop_conversion_stmtContext ctx) { } + @Override public void enterExclusionwhereclause(PostgreSqlParser.ExclusionwhereclauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_conversion_stmt(PostgreSqlParser.Drop_conversion_stmtContext ctx) { } + @Override public void exitExclusionwhereclause(PostgreSqlParser.ExclusionwhereclauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_database_stmt(PostgreSqlParser.Drop_database_stmtContext ctx) { } + @Override public void enterKey_actions(PostgreSqlParser.Key_actionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_database_stmt(PostgreSqlParser.Drop_database_stmtContext ctx) { } + @Override public void exitKey_actions(PostgreSqlParser.Key_actionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_domain_stmt(PostgreSqlParser.Drop_domain_stmtContext ctx) { } + @Override public void enterKey_update(PostgreSqlParser.Key_updateContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_domain_stmt(PostgreSqlParser.Drop_domain_stmtContext ctx) { } + @Override public void exitKey_update(PostgreSqlParser.Key_updateContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_event_trigger_stmt(PostgreSqlParser.Drop_event_trigger_stmtContext ctx) { } + @Override public void enterKey_delete(PostgreSqlParser.Key_deleteContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_event_trigger_stmt(PostgreSqlParser.Drop_event_trigger_stmtContext ctx) { } + @Override public void exitKey_delete(PostgreSqlParser.Key_deleteContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_extension_stmt(PostgreSqlParser.Drop_extension_stmtContext ctx) { } + @Override public void enterKey_action(PostgreSqlParser.Key_actionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_extension_stmt(PostgreSqlParser.Drop_extension_stmtContext ctx) { } + @Override public void exitKey_action(PostgreSqlParser.Key_actionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_foreign_data_wrapper_stmt(PostgreSqlParser.Drop_foreign_data_wrapper_stmtContext ctx) { } + @Override public void enterOptinherit(PostgreSqlParser.OptinheritContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_foreign_data_wrapper_stmt(PostgreSqlParser.Drop_foreign_data_wrapper_stmtContext ctx) { } + @Override public void exitOptinherit(PostgreSqlParser.OptinheritContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_foreign_table_stmt(PostgreSqlParser.Drop_foreign_table_stmtContext ctx) { } + @Override public void enterOptpartitionspec(PostgreSqlParser.OptpartitionspecContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_foreign_table_stmt(PostgreSqlParser.Drop_foreign_table_stmtContext ctx) { } + @Override public void exitOptpartitionspec(PostgreSqlParser.OptpartitionspecContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_function_stmt(PostgreSqlParser.Drop_function_stmtContext ctx) { } + @Override public void enterPartitionspec(PostgreSqlParser.PartitionspecContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_function_stmt(PostgreSqlParser.Drop_function_stmtContext ctx) { } + @Override public void exitPartitionspec(PostgreSqlParser.PartitionspecContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_group_stmt(PostgreSqlParser.Drop_group_stmtContext ctx) { } + @Override public void enterPart_params(PostgreSqlParser.Part_paramsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_group_stmt(PostgreSqlParser.Drop_group_stmtContext ctx) { } + @Override public void exitPart_params(PostgreSqlParser.Part_paramsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_index_stmt(PostgreSqlParser.Drop_index_stmtContext ctx) { } + @Override public void enterPart_elem(PostgreSqlParser.Part_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_index_stmt(PostgreSqlParser.Drop_index_stmtContext ctx) { } + @Override public void exitPart_elem(PostgreSqlParser.Part_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_language_stmt(PostgreSqlParser.Drop_language_stmtContext ctx) { } + @Override public void enterTable_access_method_clause(PostgreSqlParser.Table_access_method_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_language_stmt(PostgreSqlParser.Drop_language_stmtContext ctx) { } + @Override public void exitTable_access_method_clause(PostgreSqlParser.Table_access_method_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_materialized_view_stmt(PostgreSqlParser.Drop_materialized_view_stmtContext ctx) { } + @Override public void enterOptwith(PostgreSqlParser.OptwithContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_materialized_view_stmt(PostgreSqlParser.Drop_materialized_view_stmtContext ctx) { } + @Override public void exitOptwith(PostgreSqlParser.OptwithContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_operator_stmt(PostgreSqlParser.Drop_operator_stmtContext ctx) { } + @Override public void enterOncommitoption(PostgreSqlParser.OncommitoptionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_operator_stmt(PostgreSqlParser.Drop_operator_stmtContext ctx) { } + @Override public void exitOncommitoption(PostgreSqlParser.OncommitoptionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_operator_class_stmt(PostgreSqlParser.Drop_operator_class_stmtContext ctx) { } + @Override public void enterOpttablespace(PostgreSqlParser.OpttablespaceContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_operator_class_stmt(PostgreSqlParser.Drop_operator_class_stmtContext ctx) { } + @Override public void exitOpttablespace(PostgreSqlParser.OpttablespaceContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_operator_family_stmt(PostgreSqlParser.Drop_operator_family_stmtContext ctx) { } + @Override public void enterOptconstablespace(PostgreSqlParser.OptconstablespaceContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_operator_family_stmt(PostgreSqlParser.Drop_operator_family_stmtContext ctx) { } + @Override public void exitOptconstablespace(PostgreSqlParser.OptconstablespaceContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_owned_stmt(PostgreSqlParser.Drop_owned_stmtContext ctx) { } + @Override public void enterExistingindex(PostgreSqlParser.ExistingindexContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_owned_stmt(PostgreSqlParser.Drop_owned_stmtContext ctx) { } + @Override public void exitExistingindex(PostgreSqlParser.ExistingindexContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_policy_stmt(PostgreSqlParser.Drop_policy_stmtContext ctx) { } + @Override public void enterCreatestatsstmt(PostgreSqlParser.CreatestatsstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_policy_stmt(PostgreSqlParser.Drop_policy_stmtContext ctx) { } + @Override public void exitCreatestatsstmt(PostgreSqlParser.CreatestatsstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_publication_stmt(PostgreSqlParser.Drop_publication_stmtContext ctx) { } + @Override public void enterAlterstatsstmt(PostgreSqlParser.AlterstatsstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_publication_stmt(PostgreSqlParser.Drop_publication_stmtContext ctx) { } + @Override public void exitAlterstatsstmt(PostgreSqlParser.AlterstatsstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_role_stmt(PostgreSqlParser.Drop_role_stmtContext ctx) { } + @Override public void enterCreateasstmt(PostgreSqlParser.CreateasstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_role_stmt(PostgreSqlParser.Drop_role_stmtContext ctx) { } + @Override public void exitCreateasstmt(PostgreSqlParser.CreateasstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_rule_stmt(PostgreSqlParser.Drop_rule_stmtContext ctx) { } + @Override public void enterCreate_as_target(PostgreSqlParser.Create_as_targetContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_rule_stmt(PostgreSqlParser.Drop_rule_stmtContext ctx) { } + @Override public void exitCreate_as_target(PostgreSqlParser.Create_as_targetContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_schema_stmt(PostgreSqlParser.Drop_schema_stmtContext ctx) { } + @Override public void enterOpt_with_data(PostgreSqlParser.Opt_with_dataContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_schema_stmt(PostgreSqlParser.Drop_schema_stmtContext ctx) { } + @Override public void exitOpt_with_data(PostgreSqlParser.Opt_with_dataContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_sequence_stmt(PostgreSqlParser.Drop_sequence_stmtContext ctx) { } + @Override public void enterCreatematviewstmt(PostgreSqlParser.CreatematviewstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_sequence_stmt(PostgreSqlParser.Drop_sequence_stmtContext ctx) { } + @Override public void exitCreatematviewstmt(PostgreSqlParser.CreatematviewstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_server_stmt(PostgreSqlParser.Drop_server_stmtContext ctx) { } + @Override public void enterCreate_mv_target(PostgreSqlParser.Create_mv_targetContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_server_stmt(PostgreSqlParser.Drop_server_stmtContext ctx) { } + @Override public void exitCreate_mv_target(PostgreSqlParser.Create_mv_targetContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_statistics_stmt(PostgreSqlParser.Drop_statistics_stmtContext ctx) { } + @Override public void enterOptnolog(PostgreSqlParser.OptnologContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_statistics_stmt(PostgreSqlParser.Drop_statistics_stmtContext ctx) { } + @Override public void exitOptnolog(PostgreSqlParser.OptnologContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_subscription_stmt(PostgreSqlParser.Drop_subscription_stmtContext ctx) { } + @Override public void enterRefreshmatviewstmt(PostgreSqlParser.RefreshmatviewstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_subscription_stmt(PostgreSqlParser.Drop_subscription_stmtContext ctx) { } + @Override public void exitRefreshmatviewstmt(PostgreSqlParser.RefreshmatviewstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_table_stmt(PostgreSqlParser.Drop_table_stmtContext ctx) { } + @Override public void enterCreateseqstmt(PostgreSqlParser.CreateseqstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_table_stmt(PostgreSqlParser.Drop_table_stmtContext ctx) { } + @Override public void exitCreateseqstmt(PostgreSqlParser.CreateseqstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_tablespace_stmt(PostgreSqlParser.Drop_tablespace_stmtContext ctx) { } + @Override public void enterAlterseqstmt(PostgreSqlParser.AlterseqstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_tablespace_stmt(PostgreSqlParser.Drop_tablespace_stmtContext ctx) { } + @Override public void exitAlterseqstmt(PostgreSqlParser.AlterseqstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_text_search_config_stmt(PostgreSqlParser.Drop_text_search_config_stmtContext ctx) { } + @Override public void enterOptseqoptlist(PostgreSqlParser.OptseqoptlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_text_search_config_stmt(PostgreSqlParser.Drop_text_search_config_stmtContext ctx) { } + @Override public void exitOptseqoptlist(PostgreSqlParser.OptseqoptlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_text_search_dict_stmt(PostgreSqlParser.Drop_text_search_dict_stmtContext ctx) { } + @Override public void enterOptparenthesizedseqoptlist(PostgreSqlParser.OptparenthesizedseqoptlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_text_search_dict_stmt(PostgreSqlParser.Drop_text_search_dict_stmtContext ctx) { } + @Override public void exitOptparenthesizedseqoptlist(PostgreSqlParser.OptparenthesizedseqoptlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_text_search_parser_stmt(PostgreSqlParser.Drop_text_search_parser_stmtContext ctx) { } + @Override public void enterSeqoptlist(PostgreSqlParser.SeqoptlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_text_search_parser_stmt(PostgreSqlParser.Drop_text_search_parser_stmtContext ctx) { } + @Override public void exitSeqoptlist(PostgreSqlParser.SeqoptlistContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_text_search_template_stmt(PostgreSqlParser.Drop_text_search_template_stmtContext ctx) { } + @Override public void enterSeqoptelem(PostgreSqlParser.SeqoptelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_text_search_template_stmt(PostgreSqlParser.Drop_text_search_template_stmtContext ctx) { } + @Override public void exitSeqoptelem(PostgreSqlParser.SeqoptelemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_transform_stmt(PostgreSqlParser.Drop_transform_stmtContext ctx) { } + @Override public void enterOpt_by(PostgreSqlParser.Opt_byContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_transform_stmt(PostgreSqlParser.Drop_transform_stmtContext ctx) { } + @Override public void exitOpt_by(PostgreSqlParser.Opt_byContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_trigger_stmt(PostgreSqlParser.Drop_trigger_stmtContext ctx) { } + @Override public void enterNumericonly(PostgreSqlParser.NumericonlyContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_trigger_stmt(PostgreSqlParser.Drop_trigger_stmtContext ctx) { } + @Override public void exitNumericonly(PostgreSqlParser.NumericonlyContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_type_stmt(PostgreSqlParser.Drop_type_stmtContext ctx) { } + @Override public void enterNumericonly_list(PostgreSqlParser.Numericonly_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_type_stmt(PostgreSqlParser.Drop_type_stmtContext ctx) { } + @Override public void exitNumericonly_list(PostgreSqlParser.Numericonly_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_user_stmt(PostgreSqlParser.Drop_user_stmtContext ctx) { } + @Override public void enterCreateplangstmt(PostgreSqlParser.CreateplangstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_user_stmt(PostgreSqlParser.Drop_user_stmtContext ctx) { } + @Override public void exitCreateplangstmt(PostgreSqlParser.CreateplangstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_user_mapping_stmt(PostgreSqlParser.Drop_user_mapping_stmtContext ctx) { } + @Override public void enterOpt_trusted(PostgreSqlParser.Opt_trustedContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_user_mapping_stmt(PostgreSqlParser.Drop_user_mapping_stmtContext ctx) { } + @Override public void exitOpt_trusted(PostgreSqlParser.Opt_trustedContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterDrop_view_stmt(PostgreSqlParser.Drop_view_stmtContext ctx) { } + @Override public void enterHandler_name(PostgreSqlParser.Handler_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitDrop_view_stmt(PostgreSqlParser.Drop_view_stmtContext ctx) { } + @Override public void exitHandler_name(PostgreSqlParser.Handler_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterExecute_stmt(PostgreSqlParser.Execute_stmtContext ctx) { } + @Override public void enterOpt_inline_handler(PostgreSqlParser.Opt_inline_handlerContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitExecute_stmt(PostgreSqlParser.Execute_stmtContext ctx) { } + @Override public void exitOpt_inline_handler(PostgreSqlParser.Opt_inline_handlerContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterExplain_stmt(PostgreSqlParser.Explain_stmtContext ctx) { } + @Override public void enterValidator_clause(PostgreSqlParser.Validator_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitExplain_stmt(PostgreSqlParser.Explain_stmtContext ctx) { } + @Override public void exitValidator_clause(PostgreSqlParser.Validator_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFetch_stmt(PostgreSqlParser.Fetch_stmtContext ctx) { } + @Override public void enterOpt_validator(PostgreSqlParser.Opt_validatorContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFetch_stmt(PostgreSqlParser.Fetch_stmtContext ctx) { } + @Override public void exitOpt_validator(PostgreSqlParser.Opt_validatorContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterGrant_stmt(PostgreSqlParser.Grant_stmtContext ctx) { } + @Override public void enterOpt_procedural(PostgreSqlParser.Opt_proceduralContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitGrant_stmt(PostgreSqlParser.Grant_stmtContext ctx) { } + @Override public void exitOpt_procedural(PostgreSqlParser.Opt_proceduralContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterImport_foreign_schema_stmt(PostgreSqlParser.Import_foreign_schema_stmtContext ctx) { } + @Override public void enterCreatetablespacestmt(PostgreSqlParser.CreatetablespacestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitImport_foreign_schema_stmt(PostgreSqlParser.Import_foreign_schema_stmtContext ctx) { } + @Override public void exitCreatetablespacestmt(PostgreSqlParser.CreatetablespacestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterInsert_stmt(PostgreSqlParser.Insert_stmtContext ctx) { } + @Override public void enterOpttablespaceowner(PostgreSqlParser.OpttablespaceownerContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitInsert_stmt(PostgreSqlParser.Insert_stmtContext ctx) { } + @Override public void exitOpttablespaceowner(PostgreSqlParser.OpttablespaceownerContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterListen_stmt(PostgreSqlParser.Listen_stmtContext ctx) { } + @Override public void enterDroptablespacestmt(PostgreSqlParser.DroptablespacestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitListen_stmt(PostgreSqlParser.Listen_stmtContext ctx) { } + @Override public void exitDroptablespacestmt(PostgreSqlParser.DroptablespacestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterLoad_stmt(PostgreSqlParser.Load_stmtContext ctx) { } + @Override public void enterCreateextensionstmt(PostgreSqlParser.CreateextensionstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitLoad_stmt(PostgreSqlParser.Load_stmtContext ctx) { } + @Override public void exitCreateextensionstmt(PostgreSqlParser.CreateextensionstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterLock_stmt(PostgreSqlParser.Lock_stmtContext ctx) { } + @Override public void enterCreate_extension_opt_list(PostgreSqlParser.Create_extension_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitLock_stmt(PostgreSqlParser.Lock_stmtContext ctx) { } + @Override public void exitCreate_extension_opt_list(PostgreSqlParser.Create_extension_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterMove_stmt(PostgreSqlParser.Move_stmtContext ctx) { } + @Override public void enterCreate_extension_opt_item(PostgreSqlParser.Create_extension_opt_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitMove_stmt(PostgreSqlParser.Move_stmtContext ctx) { } + @Override public void exitCreate_extension_opt_item(PostgreSqlParser.Create_extension_opt_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterNotify_stmt(PostgreSqlParser.Notify_stmtContext ctx) { } + @Override public void enterAlterextensionstmt(PostgreSqlParser.AlterextensionstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitNotify_stmt(PostgreSqlParser.Notify_stmtContext ctx) { } + @Override public void exitAlterextensionstmt(PostgreSqlParser.AlterextensionstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterPrepare_stmt(PostgreSqlParser.Prepare_stmtContext ctx) { } + @Override public void enterAlter_extension_opt_list(PostgreSqlParser.Alter_extension_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitPrepare_stmt(PostgreSqlParser.Prepare_stmtContext ctx) { } + @Override public void exitAlter_extension_opt_list(PostgreSqlParser.Alter_extension_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterPrepare_transaction_stmt(PostgreSqlParser.Prepare_transaction_stmtContext ctx) { } + @Override public void enterAlter_extension_opt_item(PostgreSqlParser.Alter_extension_opt_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitPrepare_transaction_stmt(PostgreSqlParser.Prepare_transaction_stmtContext ctx) { } + @Override public void exitAlter_extension_opt_item(PostgreSqlParser.Alter_extension_opt_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterReassign_owned_stmt(PostgreSqlParser.Reassign_owned_stmtContext ctx) { } + @Override public void enterAlterextensioncontentsstmt(PostgreSqlParser.AlterextensioncontentsstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitReassign_owned_stmt(PostgreSqlParser.Reassign_owned_stmtContext ctx) { } + @Override public void exitAlterextensioncontentsstmt(PostgreSqlParser.AlterextensioncontentsstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterRefresh_materialized_view_stmt(PostgreSqlParser.Refresh_materialized_view_stmtContext ctx) { } + @Override public void enterCreatefdwstmt(PostgreSqlParser.CreatefdwstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitRefresh_materialized_view_stmt(PostgreSqlParser.Refresh_materialized_view_stmtContext ctx) { } + @Override public void exitCreatefdwstmt(PostgreSqlParser.CreatefdwstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterReindex_stmt(PostgreSqlParser.Reindex_stmtContext ctx) { } + @Override public void enterFdw_option(PostgreSqlParser.Fdw_optionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitReindex_stmt(PostgreSqlParser.Reindex_stmtContext ctx) { } + @Override public void exitFdw_option(PostgreSqlParser.Fdw_optionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterRelease_savepoint_stmt(PostgreSqlParser.Release_savepoint_stmtContext ctx) { } + @Override public void enterFdw_options(PostgreSqlParser.Fdw_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitRelease_savepoint_stmt(PostgreSqlParser.Release_savepoint_stmtContext ctx) { } + @Override public void exitFdw_options(PostgreSqlParser.Fdw_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterReset_stmt(PostgreSqlParser.Reset_stmtContext ctx) { } + @Override public void enterOpt_fdw_options(PostgreSqlParser.Opt_fdw_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitReset_stmt(PostgreSqlParser.Reset_stmtContext ctx) { } + @Override public void exitOpt_fdw_options(PostgreSqlParser.Opt_fdw_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterRevoke_stmt(PostgreSqlParser.Revoke_stmtContext ctx) { } + @Override public void enterAlterfdwstmt(PostgreSqlParser.AlterfdwstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitRevoke_stmt(PostgreSqlParser.Revoke_stmtContext ctx) { } + @Override public void exitAlterfdwstmt(PostgreSqlParser.AlterfdwstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterRollback_stmt(PostgreSqlParser.Rollback_stmtContext ctx) { } + @Override public void enterCreate_generic_options(PostgreSqlParser.Create_generic_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitRollback_stmt(PostgreSqlParser.Rollback_stmtContext ctx) { } + @Override public void exitCreate_generic_options(PostgreSqlParser.Create_generic_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterRollback_prepared_stmt(PostgreSqlParser.Rollback_prepared_stmtContext ctx) { } + @Override public void enterGeneric_option_list(PostgreSqlParser.Generic_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitRollback_prepared_stmt(PostgreSqlParser.Rollback_prepared_stmtContext ctx) { } + @Override public void exitGeneric_option_list(PostgreSqlParser.Generic_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterRollback_to_savepoint_stmt(PostgreSqlParser.Rollback_to_savepoint_stmtContext ctx) { } + @Override public void enterAlter_generic_options(PostgreSqlParser.Alter_generic_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitRollback_to_savepoint_stmt(PostgreSqlParser.Rollback_to_savepoint_stmtContext ctx) { } + @Override public void exitAlter_generic_options(PostgreSqlParser.Alter_generic_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSavepoint_stmt(PostgreSqlParser.Savepoint_stmtContext ctx) { } + @Override public void enterAlter_generic_option_list(PostgreSqlParser.Alter_generic_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSavepoint_stmt(PostgreSqlParser.Savepoint_stmtContext ctx) { } + @Override public void exitAlter_generic_option_list(PostgreSqlParser.Alter_generic_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSecurity_label_stmt(PostgreSqlParser.Security_label_stmtContext ctx) { } + @Override public void enterAlter_generic_option_elem(PostgreSqlParser.Alter_generic_option_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSecurity_label_stmt(PostgreSqlParser.Security_label_stmtContext ctx) { } + @Override public void exitAlter_generic_option_elem(PostgreSqlParser.Alter_generic_option_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSelect_stmt(PostgreSqlParser.Select_stmtContext ctx) { } + @Override public void enterGeneric_option_elem(PostgreSqlParser.Generic_option_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSelect_stmt(PostgreSqlParser.Select_stmtContext ctx) { } + @Override public void exitGeneric_option_elem(PostgreSqlParser.Generic_option_elemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSelect_into_stmt(PostgreSqlParser.Select_into_stmtContext ctx) { } + @Override public void enterGeneric_option_name(PostgreSqlParser.Generic_option_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSelect_into_stmt(PostgreSqlParser.Select_into_stmtContext ctx) { } + @Override public void exitGeneric_option_name(PostgreSqlParser.Generic_option_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterWith_clause(PostgreSqlParser.With_clauseContext ctx) { } + @Override public void enterGeneric_option_arg(PostgreSqlParser.Generic_option_argContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitWith_clause(PostgreSqlParser.With_clauseContext ctx) { } + @Override public void exitGeneric_option_arg(PostgreSqlParser.Generic_option_argContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterWith_expr(PostgreSqlParser.With_exprContext ctx) { } + @Override public void enterCreateforeignserverstmt(PostgreSqlParser.CreateforeignserverstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitWith_expr(PostgreSqlParser.With_exprContext ctx) { } + @Override public void exitCreateforeignserverstmt(PostgreSqlParser.CreateforeignserverstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSet_stmt(PostgreSqlParser.Set_stmtContext ctx) { } + @Override public void enterOpt_type(PostgreSqlParser.Opt_typeContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSet_stmt(PostgreSqlParser.Set_stmtContext ctx) { } + @Override public void exitOpt_type(PostgreSqlParser.Opt_typeContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSet_constraints_stmt(PostgreSqlParser.Set_constraints_stmtContext ctx) { } + @Override public void enterForeign_server_version(PostgreSqlParser.Foreign_server_versionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSet_constraints_stmt(PostgreSqlParser.Set_constraints_stmtContext ctx) { } + @Override public void exitForeign_server_version(PostgreSqlParser.Foreign_server_versionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSet_role_stmt(PostgreSqlParser.Set_role_stmtContext ctx) { } + @Override public void enterOpt_foreign_server_version(PostgreSqlParser.Opt_foreign_server_versionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSet_role_stmt(PostgreSqlParser.Set_role_stmtContext ctx) { } + @Override public void exitOpt_foreign_server_version(PostgreSqlParser.Opt_foreign_server_versionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSet_session_authorization_stmt(PostgreSqlParser.Set_session_authorization_stmtContext ctx) { } + @Override public void enterAlterforeignserverstmt(PostgreSqlParser.AlterforeignserverstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSet_session_authorization_stmt(PostgreSqlParser.Set_session_authorization_stmtContext ctx) { } + @Override public void exitAlterforeignserverstmt(PostgreSqlParser.AlterforeignserverstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterTransaction_mode(PostgreSqlParser.Transaction_modeContext ctx) { } + @Override public void enterCreateforeigntablestmt(PostgreSqlParser.CreateforeigntablestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitTransaction_mode(PostgreSqlParser.Transaction_modeContext ctx) { } + @Override public void exitCreateforeigntablestmt(PostgreSqlParser.CreateforeigntablestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImportforeignschemastmt(PostgreSqlParser.ImportforeignschemastmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImportforeignschemastmt(PostgreSqlParser.ImportforeignschemastmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImport_qualification_type(PostgreSqlParser.Import_qualification_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImport_qualification_type(PostgreSqlParser.Import_qualification_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImport_qualification(PostgreSqlParser.Import_qualificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImport_qualification(PostgreSqlParser.Import_qualificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateusermappingstmt(PostgreSqlParser.CreateusermappingstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateusermappingstmt(PostgreSqlParser.CreateusermappingstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAuth_ident(PostgreSqlParser.Auth_identContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAuth_ident(PostgreSqlParser.Auth_identContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropusermappingstmt(PostgreSqlParser.DropusermappingstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropusermappingstmt(PostgreSqlParser.DropusermappingstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterusermappingstmt(PostgreSqlParser.AlterusermappingstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterusermappingstmt(PostgreSqlParser.AlterusermappingstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatepolicystmt(PostgreSqlParser.CreatepolicystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatepolicystmt(PostgreSqlParser.CreatepolicystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterpolicystmt(PostgreSqlParser.AlterpolicystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterpolicystmt(PostgreSqlParser.AlterpolicystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRowsecurityoptionalexpr(PostgreSqlParser.RowsecurityoptionalexprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRowsecurityoptionalexpr(PostgreSqlParser.RowsecurityoptionalexprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRowsecurityoptionalwithcheck(PostgreSqlParser.RowsecurityoptionalwithcheckContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRowsecurityoptionalwithcheck(PostgreSqlParser.RowsecurityoptionalwithcheckContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRowsecuritydefaulttorole(PostgreSqlParser.RowsecuritydefaulttoroleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRowsecuritydefaulttorole(PostgreSqlParser.RowsecuritydefaulttoroleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRowsecurityoptionaltorole(PostgreSqlParser.RowsecurityoptionaltoroleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRowsecurityoptionaltorole(PostgreSqlParser.RowsecurityoptionaltoroleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRowsecuritydefaultpermissive(PostgreSqlParser.RowsecuritydefaultpermissiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRowsecuritydefaultpermissive(PostgreSqlParser.RowsecuritydefaultpermissiveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRowsecuritydefaultforcmd(PostgreSqlParser.RowsecuritydefaultforcmdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRowsecuritydefaultforcmd(PostgreSqlParser.RowsecuritydefaultforcmdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRow_security_cmd(PostgreSqlParser.Row_security_cmdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRow_security_cmd(PostgreSqlParser.Row_security_cmdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateamstmt(PostgreSqlParser.CreateamstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateamstmt(PostgreSqlParser.CreateamstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAm_type(PostgreSqlParser.Am_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAm_type(PostgreSqlParser.Am_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatetrigstmt(PostgreSqlParser.CreatetrigstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatetrigstmt(PostgreSqlParser.CreatetrigstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggeractiontime(PostgreSqlParser.TriggeractiontimeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggeractiontime(PostgreSqlParser.TriggeractiontimeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggerevents(PostgreSqlParser.TriggereventsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggerevents(PostgreSqlParser.TriggereventsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggeroneevent(PostgreSqlParser.TriggeroneeventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggeroneevent(PostgreSqlParser.TriggeroneeventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggerreferencing(PostgreSqlParser.TriggerreferencingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggerreferencing(PostgreSqlParser.TriggerreferencingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggertransitions(PostgreSqlParser.TriggertransitionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggertransitions(PostgreSqlParser.TriggertransitionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggertransition(PostgreSqlParser.TriggertransitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggertransition(PostgreSqlParser.TriggertransitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransitionoldornew(PostgreSqlParser.TransitionoldornewContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransitionoldornew(PostgreSqlParser.TransitionoldornewContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransitionrowortable(PostgreSqlParser.TransitionrowortableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransitionrowortable(PostgreSqlParser.TransitionrowortableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransitionrelname(PostgreSqlParser.TransitionrelnameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransitionrelname(PostgreSqlParser.TransitionrelnameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggerforspec(PostgreSqlParser.TriggerforspecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggerforspec(PostgreSqlParser.TriggerforspecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggerforopteach(PostgreSqlParser.TriggerforopteachContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggerforopteach(PostgreSqlParser.TriggerforopteachContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggerfortype(PostgreSqlParser.TriggerfortypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggerfortype(PostgreSqlParser.TriggerfortypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggerwhen(PostgreSqlParser.TriggerwhenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggerwhen(PostgreSqlParser.TriggerwhenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunction_or_procedure(PostgreSqlParser.Function_or_procedureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunction_or_procedure(PostgreSqlParser.Function_or_procedureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggerfuncargs(PostgreSqlParser.TriggerfuncargsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggerfuncargs(PostgreSqlParser.TriggerfuncargsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTriggerfuncarg(PostgreSqlParser.TriggerfuncargContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTriggerfuncarg(PostgreSqlParser.TriggerfuncargContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOptconstrfromtable(PostgreSqlParser.OptconstrfromtableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOptconstrfromtable(PostgreSqlParser.OptconstrfromtableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstraintattributespec(PostgreSqlParser.ConstraintattributespecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstraintattributespec(PostgreSqlParser.ConstraintattributespecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstraintattributeElem(PostgreSqlParser.ConstraintattributeElemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstraintattributeElem(PostgreSqlParser.ConstraintattributeElemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateeventtrigstmt(PostgreSqlParser.CreateeventtrigstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateeventtrigstmt(PostgreSqlParser.CreateeventtrigstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEvent_trigger_when_list(PostgreSqlParser.Event_trigger_when_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEvent_trigger_when_list(PostgreSqlParser.Event_trigger_when_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEvent_trigger_when_item(PostgreSqlParser.Event_trigger_when_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEvent_trigger_when_item(PostgreSqlParser.Event_trigger_when_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEvent_trigger_value_list(PostgreSqlParser.Event_trigger_value_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEvent_trigger_value_list(PostgreSqlParser.Event_trigger_value_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAltereventtrigstmt(PostgreSqlParser.AltereventtrigstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAltereventtrigstmt(PostgreSqlParser.AltereventtrigstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnable_trigger(PostgreSqlParser.Enable_triggerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnable_trigger(PostgreSqlParser.Enable_triggerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateassertionstmt(PostgreSqlParser.CreateassertionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateassertionstmt(PostgreSqlParser.CreateassertionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefinestmt(PostgreSqlParser.DefinestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefinestmt(PostgreSqlParser.DefinestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefinition(PostgreSqlParser.DefinitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefinition(PostgreSqlParser.DefinitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDef_list(PostgreSqlParser.Def_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDef_list(PostgreSqlParser.Def_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDef_elem(PostgreSqlParser.Def_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDef_elem(PostgreSqlParser.Def_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDef_arg(PostgreSqlParser.Def_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDef_arg(PostgreSqlParser.Def_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOld_aggr_definition(PostgreSqlParser.Old_aggr_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOld_aggr_definition(PostgreSqlParser.Old_aggr_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOld_aggr_list(PostgreSqlParser.Old_aggr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOld_aggr_list(PostgreSqlParser.Old_aggr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOld_aggr_elem(PostgreSqlParser.Old_aggr_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOld_aggr_elem(PostgreSqlParser.Old_aggr_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_enum_val_list(PostgreSqlParser.Opt_enum_val_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_enum_val_list(PostgreSqlParser.Opt_enum_val_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnum_val_list(PostgreSqlParser.Enum_val_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnum_val_list(PostgreSqlParser.Enum_val_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterenumstmt(PostgreSqlParser.AlterenumstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterenumstmt(PostgreSqlParser.AlterenumstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_if_not_exists(PostgreSqlParser.Opt_if_not_existsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_if_not_exists(PostgreSqlParser.Opt_if_not_existsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateopclassstmt(PostgreSqlParser.CreateopclassstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateopclassstmt(PostgreSqlParser.CreateopclassstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpclass_item_list(PostgreSqlParser.Opclass_item_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpclass_item_list(PostgreSqlParser.Opclass_item_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpclass_item(PostgreSqlParser.Opclass_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpclass_item(PostgreSqlParser.Opclass_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_default(PostgreSqlParser.Opt_defaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_default(PostgreSqlParser.Opt_defaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_opfamily(PostgreSqlParser.Opt_opfamilyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_opfamily(PostgreSqlParser.Opt_opfamilyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpclass_purpose(PostgreSqlParser.Opclass_purposeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpclass_purpose(PostgreSqlParser.Opclass_purposeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_recheck(PostgreSqlParser.Opt_recheckContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_recheck(PostgreSqlParser.Opt_recheckContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreateopfamilystmt(PostgreSqlParser.CreateopfamilystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreateopfamilystmt(PostgreSqlParser.CreateopfamilystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlteropfamilystmt(PostgreSqlParser.AlteropfamilystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlteropfamilystmt(PostgreSqlParser.AlteropfamilystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpclass_drop_list(PostgreSqlParser.Opclass_drop_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpclass_drop_list(PostgreSqlParser.Opclass_drop_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpclass_drop(PostgreSqlParser.Opclass_dropContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpclass_drop(PostgreSqlParser.Opclass_dropContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropopclassstmt(PostgreSqlParser.DropopclassstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropopclassstmt(PostgreSqlParser.DropopclassstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropopfamilystmt(PostgreSqlParser.DropopfamilystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropopfamilystmt(PostgreSqlParser.DropopfamilystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropownedstmt(PostgreSqlParser.DropownedstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropownedstmt(PostgreSqlParser.DropownedstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReassignownedstmt(PostgreSqlParser.ReassignownedstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReassignownedstmt(PostgreSqlParser.ReassignownedstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropstmt(PostgreSqlParser.DropstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropstmt(PostgreSqlParser.DropstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObject_type_any_name(PostgreSqlParser.Object_type_any_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObject_type_any_name(PostgreSqlParser.Object_type_any_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObject_type_name(PostgreSqlParser.Object_type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObject_type_name(PostgreSqlParser.Object_type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDrop_type_name(PostgreSqlParser.Drop_type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDrop_type_name(PostgreSqlParser.Drop_type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterObject_type_name_on_any_name(PostgreSqlParser.Object_type_name_on_any_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitObject_type_name_on_any_name(PostgreSqlParser.Object_type_name_on_any_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAny_name_list(PostgreSqlParser.Any_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAny_name_list(PostgreSqlParser.Any_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAny_name(PostgreSqlParser.Any_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAny_name(PostgreSqlParser.Any_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttrs(PostgreSqlParser.AttrsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttrs(PostgreSqlParser.AttrsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_name_list(PostgreSqlParser.Type_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_name_list(PostgreSqlParser.Type_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTruncatestmt(PostgreSqlParser.TruncatestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTruncatestmt(PostgreSqlParser.TruncatestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_restart_seqs(PostgreSqlParser.Opt_restart_seqsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_restart_seqs(PostgreSqlParser.Opt_restart_seqsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCommentstmt(PostgreSqlParser.CommentstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCommentstmt(PostgreSqlParser.CommentstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterComment_text(PostgreSqlParser.Comment_textContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitComment_text(PostgreSqlParser.Comment_textContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSeclabelstmt(PostgreSqlParser.SeclabelstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSeclabelstmt(PostgreSqlParser.SeclabelstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_provider(PostgreSqlParser.Opt_providerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_provider(PostgreSqlParser.Opt_providerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSecurity_label(PostgreSqlParser.Security_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSecurity_label(PostgreSqlParser.Security_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFetchstmt(PostgreSqlParser.FetchstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFetchstmt(PostgreSqlParser.FetchstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFetch_args(PostgreSqlParser.Fetch_argsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFetch_args(PostgreSqlParser.Fetch_argsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrom_in(PostgreSqlParser.From_inContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrom_in(PostgreSqlParser.From_inContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_from_in(PostgreSqlParser.Opt_from_inContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_from_in(PostgreSqlParser.Opt_from_inContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGrantstmt(PostgreSqlParser.GrantstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGrantstmt(PostgreSqlParser.GrantstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRevokestmt(PostgreSqlParser.RevokestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRevokestmt(PostgreSqlParser.RevokestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrivileges(PostgreSqlParser.PrivilegesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrivileges(PostgreSqlParser.PrivilegesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrivilege_list(PostgreSqlParser.Privilege_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrivilege_list(PostgreSqlParser.Privilege_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrivilege(PostgreSqlParser.PrivilegeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrivilege(PostgreSqlParser.PrivilegeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrivilege_target(PostgreSqlParser.Privilege_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrivilege_target(PostgreSqlParser.Privilege_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGrantee_list(PostgreSqlParser.Grantee_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGrantee_list(PostgreSqlParser.Grantee_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGrantee(PostgreSqlParser.GranteeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGrantee(PostgreSqlParser.GranteeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_grant_grant_option(PostgreSqlParser.Opt_grant_grant_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_grant_grant_option(PostgreSqlParser.Opt_grant_grant_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGrantrolestmt(PostgreSqlParser.GrantrolestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGrantrolestmt(PostgreSqlParser.GrantrolestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRevokerolestmt(PostgreSqlParser.RevokerolestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRevokerolestmt(PostgreSqlParser.RevokerolestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_grant_admin_option(PostgreSqlParser.Opt_grant_admin_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_grant_admin_option(PostgreSqlParser.Opt_grant_admin_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_granted_by(PostgreSqlParser.Opt_granted_byContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_granted_by(PostgreSqlParser.Opt_granted_byContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterdefaultprivilegesstmt(PostgreSqlParser.AlterdefaultprivilegesstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterdefaultprivilegesstmt(PostgreSqlParser.AlterdefaultprivilegesstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefacloptionlist(PostgreSqlParser.DefacloptionlistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefacloptionlist(PostgreSqlParser.DefacloptionlistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefacloption(PostgreSqlParser.DefacloptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefacloption(PostgreSqlParser.DefacloptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefaclaction(PostgreSqlParser.DefaclactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefaclaction(PostgreSqlParser.DefaclactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefacl_privilege_target(PostgreSqlParser.Defacl_privilege_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefacl_privilege_target(PostgreSqlParser.Defacl_privilege_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndexstmt(PostgreSqlParser.IndexstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndexstmt(PostgreSqlParser.IndexstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_unique(PostgreSqlParser.Opt_uniqueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_unique(PostgreSqlParser.Opt_uniqueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_concurrently(PostgreSqlParser.Opt_concurrentlyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_concurrently(PostgreSqlParser.Opt_concurrentlyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_index_name(PostgreSqlParser.Opt_index_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_index_name(PostgreSqlParser.Opt_index_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAccess_method_clause(PostgreSqlParser.Access_method_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAccess_method_clause(PostgreSqlParser.Access_method_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndex_params(PostgreSqlParser.Index_paramsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndex_params(PostgreSqlParser.Index_paramsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndex_elem_options(PostgreSqlParser.Index_elem_optionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndex_elem_options(PostgreSqlParser.Index_elem_optionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndex_elem(PostgreSqlParser.Index_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndex_elem(PostgreSqlParser.Index_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_include(PostgreSqlParser.Opt_includeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_include(PostgreSqlParser.Opt_includeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndex_including_params(PostgreSqlParser.Index_including_paramsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndex_including_params(PostgreSqlParser.Index_including_paramsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_collate(PostgreSqlParser.Opt_collateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_collate(PostgreSqlParser.Opt_collateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_class(PostgreSqlParser.Opt_classContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_class(PostgreSqlParser.Opt_classContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_asc_desc(PostgreSqlParser.Opt_asc_descContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_asc_desc(PostgreSqlParser.Opt_asc_descContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_nulls_order(PostgreSqlParser.Opt_nulls_orderContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_nulls_order(PostgreSqlParser.Opt_nulls_orderContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatefunctionstmt(PostgreSqlParser.CreatefunctionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatefunctionstmt(PostgreSqlParser.CreatefunctionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_or_replace(PostgreSqlParser.Opt_or_replaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_or_replace(PostgreSqlParser.Opt_or_replaceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_args(PostgreSqlParser.Func_argsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_args(PostgreSqlParser.Func_argsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_args_list(PostgreSqlParser.Func_args_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_args_list(PostgreSqlParser.Func_args_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunction_with_argtypes_list(PostgreSqlParser.Function_with_argtypes_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunction_with_argtypes_list(PostgreSqlParser.Function_with_argtypes_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunction_with_argtypes(PostgreSqlParser.Function_with_argtypesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunction_with_argtypes(PostgreSqlParser.Function_with_argtypesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_args_with_defaults(PostgreSqlParser.Func_args_with_defaultsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_args_with_defaults(PostgreSqlParser.Func_args_with_defaultsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_args_with_defaults_list(PostgreSqlParser.Func_args_with_defaults_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_args_with_defaults_list(PostgreSqlParser.Func_args_with_defaults_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_arg(PostgreSqlParser.Func_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_arg(PostgreSqlParser.Func_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArg_class(PostgreSqlParser.Arg_classContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArg_class(PostgreSqlParser.Arg_classContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParam_name(PostgreSqlParser.Param_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParam_name(PostgreSqlParser.Param_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_return(PostgreSqlParser.Func_returnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_return(PostgreSqlParser.Func_returnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_type(PostgreSqlParser.Func_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_type(PostgreSqlParser.Func_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_arg_with_default(PostgreSqlParser.Func_arg_with_defaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_arg_with_default(PostgreSqlParser.Func_arg_with_defaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggr_arg(PostgreSqlParser.Aggr_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggr_arg(PostgreSqlParser.Aggr_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggr_args(PostgreSqlParser.Aggr_argsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggr_args(PostgreSqlParser.Aggr_argsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggr_args_list(PostgreSqlParser.Aggr_args_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggr_args_list(PostgreSqlParser.Aggr_args_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggregate_with_argtypes(PostgreSqlParser.Aggregate_with_argtypesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggregate_with_argtypes(PostgreSqlParser.Aggregate_with_argtypesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggregate_with_argtypes_list(PostgreSqlParser.Aggregate_with_argtypes_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggregate_with_argtypes_list(PostgreSqlParser.Aggregate_with_argtypes_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatefunc_opt_list(PostgreSqlParser.Createfunc_opt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatefunc_opt_list(PostgreSqlParser.Createfunc_opt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCommon_func_opt_item(PostgreSqlParser.Common_func_opt_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCommon_func_opt_item(PostgreSqlParser.Common_func_opt_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatefunc_opt_item(PostgreSqlParser.Createfunc_opt_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatefunc_opt_item(PostgreSqlParser.Createfunc_opt_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_as(PostgreSqlParser.Func_asContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_as(PostgreSqlParser.Func_asContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransform_type_list(PostgreSqlParser.Transform_type_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransform_type_list(PostgreSqlParser.Transform_type_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_definition(PostgreSqlParser.Opt_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_definition(PostgreSqlParser.Opt_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTable_func_column(PostgreSqlParser.Table_func_columnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTable_func_column(PostgreSqlParser.Table_func_columnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTable_func_column_list(PostgreSqlParser.Table_func_column_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTable_func_column_list(PostgreSqlParser.Table_func_column_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterfunctionstmt(PostgreSqlParser.AlterfunctionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterfunctionstmt(PostgreSqlParser.AlterfunctionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterfunc_opt_list(PostgreSqlParser.Alterfunc_opt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterfunc_opt_list(PostgreSqlParser.Alterfunc_opt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_restrict(PostgreSqlParser.Opt_restrictContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_restrict(PostgreSqlParser.Opt_restrictContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRemovefuncstmt(PostgreSqlParser.RemovefuncstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRemovefuncstmt(PostgreSqlParser.RemovefuncstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRemoveaggrstmt(PostgreSqlParser.RemoveaggrstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRemoveaggrstmt(PostgreSqlParser.RemoveaggrstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRemoveoperstmt(PostgreSqlParser.RemoveoperstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRemoveoperstmt(PostgreSqlParser.RemoveoperstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOper_argtypes(PostgreSqlParser.Oper_argtypesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOper_argtypes(PostgreSqlParser.Oper_argtypesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAny_operator(PostgreSqlParser.Any_operatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAny_operator(PostgreSqlParser.Any_operatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOperator_with_argtypes_list(PostgreSqlParser.Operator_with_argtypes_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOperator_with_argtypes_list(PostgreSqlParser.Operator_with_argtypes_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOperator_with_argtypes(PostgreSqlParser.Operator_with_argtypesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOperator_with_argtypes(PostgreSqlParser.Operator_with_argtypesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDostmt(PostgreSqlParser.DostmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDostmt(PostgreSqlParser.DostmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDostmt_opt_list(PostgreSqlParser.Dostmt_opt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDostmt_opt_list(PostgreSqlParser.Dostmt_opt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDostmt_opt_item(PostgreSqlParser.Dostmt_opt_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDostmt_opt_item(PostgreSqlParser.Dostmt_opt_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatecaststmt(PostgreSqlParser.CreatecaststmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatecaststmt(PostgreSqlParser.CreatecaststmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCast_context(PostgreSqlParser.Cast_contextContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCast_context(PostgreSqlParser.Cast_contextContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropcaststmt(PostgreSqlParser.DropcaststmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropcaststmt(PostgreSqlParser.DropcaststmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_if_exists(PostgreSqlParser.Opt_if_existsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_if_exists(PostgreSqlParser.Opt_if_existsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatetransformstmt(PostgreSqlParser.CreatetransformstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatetransformstmt(PostgreSqlParser.CreatetransformstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransform_element_list(PostgreSqlParser.Transform_element_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransform_element_list(PostgreSqlParser.Transform_element_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDroptransformstmt(PostgreSqlParser.DroptransformstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDroptransformstmt(PostgreSqlParser.DroptransformstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReindexstmt(PostgreSqlParser.ReindexstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReindexstmt(PostgreSqlParser.ReindexstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReindex_target_type(PostgreSqlParser.Reindex_target_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReindex_target_type(PostgreSqlParser.Reindex_target_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReindex_target_multitable(PostgreSqlParser.Reindex_target_multitableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReindex_target_multitable(PostgreSqlParser.Reindex_target_multitableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReindex_option_list(PostgreSqlParser.Reindex_option_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReindex_option_list(PostgreSqlParser.Reindex_option_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReindex_option_elem(PostgreSqlParser.Reindex_option_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReindex_option_elem(PostgreSqlParser.Reindex_option_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAltertblspcstmt(PostgreSqlParser.AltertblspcstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAltertblspcstmt(PostgreSqlParser.AltertblspcstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRenamestmt(PostgreSqlParser.RenamestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRenamestmt(PostgreSqlParser.RenamestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_column(PostgreSqlParser.Opt_columnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_column(PostgreSqlParser.Opt_columnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_set_data(PostgreSqlParser.Opt_set_dataContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_set_data(PostgreSqlParser.Opt_set_dataContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterobjectdependsstmt(PostgreSqlParser.AlterobjectdependsstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterobjectdependsstmt(PostgreSqlParser.AlterobjectdependsstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_no(PostgreSqlParser.Opt_noContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_no(PostgreSqlParser.Opt_noContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterobjectschemastmt(PostgreSqlParser.AlterobjectschemastmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterobjectschemastmt(PostgreSqlParser.AlterobjectschemastmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlteroperatorstmt(PostgreSqlParser.AlteroperatorstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlteroperatorstmt(PostgreSqlParser.AlteroperatorstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOperator_def_list(PostgreSqlParser.Operator_def_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOperator_def_list(PostgreSqlParser.Operator_def_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOperator_def_elem(PostgreSqlParser.Operator_def_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOperator_def_elem(PostgreSqlParser.Operator_def_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOperator_def_arg(PostgreSqlParser.Operator_def_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOperator_def_arg(PostgreSqlParser.Operator_def_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAltertypestmt(PostgreSqlParser.AltertypestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAltertypestmt(PostgreSqlParser.AltertypestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterownerstmt(PostgreSqlParser.AlterownerstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterownerstmt(PostgreSqlParser.AlterownerstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatepublicationstmt(PostgreSqlParser.CreatepublicationstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatepublicationstmt(PostgreSqlParser.CreatepublicationstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_publication_for_tables(PostgreSqlParser.Opt_publication_for_tablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_publication_for_tables(PostgreSqlParser.Opt_publication_for_tablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPublication_for_tables(PostgreSqlParser.Publication_for_tablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPublication_for_tables(PostgreSqlParser.Publication_for_tablesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlterpublicationstmt(PostgreSqlParser.AlterpublicationstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlterpublicationstmt(PostgreSqlParser.AlterpublicationstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatesubscriptionstmt(PostgreSqlParser.CreatesubscriptionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatesubscriptionstmt(PostgreSqlParser.CreatesubscriptionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPublication_name_list(PostgreSqlParser.Publication_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPublication_name_list(PostgreSqlParser.Publication_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPublication_name_item(PostgreSqlParser.Publication_name_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPublication_name_item(PostgreSqlParser.Publication_name_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAltersubscriptionstmt(PostgreSqlParser.AltersubscriptionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAltersubscriptionstmt(PostgreSqlParser.AltersubscriptionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDropsubscriptionstmt(PostgreSqlParser.DropsubscriptionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDropsubscriptionstmt(PostgreSqlParser.DropsubscriptionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRulestmt(PostgreSqlParser.RulestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRulestmt(PostgreSqlParser.RulestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRuleactionlist(PostgreSqlParser.RuleactionlistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRuleactionlist(PostgreSqlParser.RuleactionlistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRuleactionmulti(PostgreSqlParser.RuleactionmultiContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRuleactionmulti(PostgreSqlParser.RuleactionmultiContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRuleactionstmt(PostgreSqlParser.RuleactionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRuleactionstmt(PostgreSqlParser.RuleactionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRuleactionstmtOrEmpty(PostgreSqlParser.RuleactionstmtOrEmptyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRuleactionstmtOrEmpty(PostgreSqlParser.RuleactionstmtOrEmptyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEvent(PostgreSqlParser.EventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEvent(PostgreSqlParser.EventContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_instead(PostgreSqlParser.Opt_insteadContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_instead(PostgreSqlParser.Opt_insteadContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNotifystmt(PostgreSqlParser.NotifystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNotifystmt(PostgreSqlParser.NotifystmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNotify_payload(PostgreSqlParser.Notify_payloadContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNotify_payload(PostgreSqlParser.Notify_payloadContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterListenstmt(PostgreSqlParser.ListenstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitListenstmt(PostgreSqlParser.ListenstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnlistenstmt(PostgreSqlParser.UnlistenstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnlistenstmt(PostgreSqlParser.UnlistenstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransactionstmt(PostgreSqlParser.TransactionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransactionstmt(PostgreSqlParser.TransactionstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_transaction(PostgreSqlParser.Opt_transactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_transaction(PostgreSqlParser.Opt_transactionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTransaction_mode_item(PostgreSqlParser.Transaction_mode_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransaction_mode_item(PostgreSqlParser.Transaction_mode_itemContext ctx) { } /** * {@inheritDoc} * @@ -2201,373 +4783,1297 @@ public class PostgreSqlParserBaseListener implements PostgreSqlParserListener { * *

The default implementation does nothing.

*/ - @Override public void enterSet_transaction_stmt(PostgreSqlParser.Set_transaction_stmtContext ctx) { } + @Override public void enterTransaction_mode_list_or_empty(PostgreSqlParser.Transaction_mode_list_or_emptyContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSet_transaction_stmt(PostgreSqlParser.Set_transaction_stmtContext ctx) { } + @Override public void exitTransaction_mode_list_or_empty(PostgreSqlParser.Transaction_mode_list_or_emptyContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterShow_stmt(PostgreSqlParser.Show_stmtContext ctx) { } + @Override public void enterOpt_transaction_chain(PostgreSqlParser.Opt_transaction_chainContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitShow_stmt(PostgreSqlParser.Show_stmtContext ctx) { } + @Override public void exitOpt_transaction_chain(PostgreSqlParser.Opt_transaction_chainContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterTruncate_stmt(PostgreSqlParser.Truncate_stmtContext ctx) { } + @Override public void enterViewstmt(PostgreSqlParser.ViewstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitTruncate_stmt(PostgreSqlParser.Truncate_stmtContext ctx) { } + @Override public void exitViewstmt(PostgreSqlParser.ViewstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterUnlisten_stmt(PostgreSqlParser.Unlisten_stmtContext ctx) { } + @Override public void enterOpt_check_option(PostgreSqlParser.Opt_check_optionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitUnlisten_stmt(PostgreSqlParser.Unlisten_stmtContext ctx) { } + @Override public void exitOpt_check_option(PostgreSqlParser.Opt_check_optionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterUpdate_stmt(PostgreSqlParser.Update_stmtContext ctx) { } + @Override public void enterLoadstmt(PostgreSqlParser.LoadstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitUpdate_stmt(PostgreSqlParser.Update_stmtContext ctx) { } + @Override public void exitLoadstmt(PostgreSqlParser.LoadstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterVacuum_opt(PostgreSqlParser.Vacuum_optContext ctx) { } + @Override public void enterCreatedbstmt(PostgreSqlParser.CreatedbstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitVacuum_opt(PostgreSqlParser.Vacuum_optContext ctx) { } + @Override public void exitCreatedbstmt(PostgreSqlParser.CreatedbstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterVacuum_opt_list(PostgreSqlParser.Vacuum_opt_listContext ctx) { } + @Override public void enterCreatedb_opt_list(PostgreSqlParser.Createdb_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitVacuum_opt_list(PostgreSqlParser.Vacuum_opt_listContext ctx) { } + @Override public void exitCreatedb_opt_list(PostgreSqlParser.Createdb_opt_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterVacuum_stmt(PostgreSqlParser.Vacuum_stmtContext ctx) { } + @Override public void enterCreatedb_opt_items(PostgreSqlParser.Createdb_opt_itemsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitVacuum_stmt(PostgreSqlParser.Vacuum_stmtContext ctx) { } + @Override public void exitCreatedb_opt_items(PostgreSqlParser.Createdb_opt_itemsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterValues_stmt(PostgreSqlParser.Values_stmtContext ctx) { } + @Override public void enterCreatedb_opt_item(PostgreSqlParser.Createdb_opt_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitValues_stmt(PostgreSqlParser.Values_stmtContext ctx) { } + @Override public void exitCreatedb_opt_item(PostgreSqlParser.Createdb_opt_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterSelector_clause(PostgreSqlParser.Selector_clauseContext ctx) { } + @Override public void enterCreatedb_opt_name(PostgreSqlParser.Createdb_opt_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitSelector_clause(PostgreSqlParser.Selector_clauseContext ctx) { } + @Override public void exitCreatedb_opt_name(PostgreSqlParser.Createdb_opt_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFrom_clause(PostgreSqlParser.From_clauseContext ctx) { } + @Override public void enterOpt_equal(PostgreSqlParser.Opt_equalContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFrom_clause(PostgreSqlParser.From_clauseContext ctx) { } + @Override public void exitOpt_equal(PostgreSqlParser.Opt_equalContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterWhere_clause(PostgreSqlParser.Where_clauseContext ctx) { } + @Override public void enterAlterdatabasestmt(PostgreSqlParser.AlterdatabasestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitWhere_clause(PostgreSqlParser.Where_clauseContext ctx) { } + @Override public void exitAlterdatabasestmt(PostgreSqlParser.AlterdatabasestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterGroup_by_clause(PostgreSqlParser.Group_by_clauseContext ctx) { } + @Override public void enterAlterdatabasesetstmt(PostgreSqlParser.AlterdatabasesetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitGroup_by_clause(PostgreSqlParser.Group_by_clauseContext ctx) { } + @Override public void exitAlterdatabasesetstmt(PostgreSqlParser.AlterdatabasesetstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterGrouping_elem(PostgreSqlParser.Grouping_elemContext ctx) { } + @Override public void enterDropdbstmt(PostgreSqlParser.DropdbstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitGrouping_elem(PostgreSqlParser.Grouping_elemContext ctx) { } + @Override public void exitDropdbstmt(PostgreSqlParser.DropdbstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterGrouping_elem_list(PostgreSqlParser.Grouping_elem_listContext ctx) { } + @Override public void enterDrop_option_list(PostgreSqlParser.Drop_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitGrouping_elem_list(PostgreSqlParser.Grouping_elem_listContext ctx) { } + @Override public void exitDrop_option_list(PostgreSqlParser.Drop_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterHaving_clause(PostgreSqlParser.Having_clauseContext ctx) { } + @Override public void enterDrop_option(PostgreSqlParser.Drop_optionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitHaving_clause(PostgreSqlParser.Having_clauseContext ctx) { } + @Override public void exitDrop_option(PostgreSqlParser.Drop_optionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterColumn_list(PostgreSqlParser.Column_listContext ctx) { } + @Override public void enterAltercollationstmt(PostgreSqlParser.AltercollationstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitColumn_list(PostgreSqlParser.Column_listContext ctx) { } + @Override public void exitAltercollationstmt(PostgreSqlParser.AltercollationstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterExplain_parameter(PostgreSqlParser.Explain_parameterContext ctx) { } + @Override public void enterAltersystemstmt(PostgreSqlParser.AltersystemstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitExplain_parameter(PostgreSqlParser.Explain_parameterContext ctx) { } + @Override public void exitAltersystemstmt(PostgreSqlParser.AltersystemstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFrame(PostgreSqlParser.FrameContext ctx) { } + @Override public void enterCreatedomainstmt(PostgreSqlParser.CreatedomainstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFrame(PostgreSqlParser.FrameContext ctx) { } + @Override public void exitCreatedomainstmt(PostgreSqlParser.CreatedomainstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFrame_start(PostgreSqlParser.Frame_startContext ctx) { } + @Override public void enterAlterdomainstmt(PostgreSqlParser.AlterdomainstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFrame_start(PostgreSqlParser.Frame_startContext ctx) { } + @Override public void exitAlterdomainstmt(PostgreSqlParser.AlterdomainstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFrame_end(PostgreSqlParser.Frame_endContext ctx) { } + @Override public void enterOpt_as(PostgreSqlParser.Opt_asContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFrame_end(PostgreSqlParser.Frame_endContext ctx) { } + @Override public void exitOpt_as(PostgreSqlParser.Opt_asContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFrame_clause(PostgreSqlParser.Frame_clauseContext ctx) { } + @Override public void enterAltertsdictionarystmt(PostgreSqlParser.AltertsdictionarystmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFrame_clause(PostgreSqlParser.Frame_clauseContext ctx) { } + @Override public void exitAltertsdictionarystmt(PostgreSqlParser.AltertsdictionarystmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterWindow_definition_list(PostgreSqlParser.Window_definition_listContext ctx) { } + @Override public void enterAltertsconfigurationstmt(PostgreSqlParser.AltertsconfigurationstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitWindow_definition_list(PostgreSqlParser.Window_definition_listContext ctx) { } + @Override public void exitAltertsconfigurationstmt(PostgreSqlParser.AltertsconfigurationstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterWindow_definition(PostgreSqlParser.Window_definitionContext ctx) { } + @Override public void enterAny_with(PostgreSqlParser.Any_withContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitWindow_definition(PostgreSqlParser.Window_definitionContext ctx) { } + @Override public void exitAny_with(PostgreSqlParser.Any_withContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterWindow_clause(PostgreSqlParser.Window_clauseContext ctx) { } + @Override public void enterCreateconversionstmt(PostgreSqlParser.CreateconversionstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitWindow_clause(PostgreSqlParser.Window_clauseContext ctx) { } + @Override public void exitCreateconversionstmt(PostgreSqlParser.CreateconversionstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterWindow_specification(PostgreSqlParser.Window_specificationContext ctx) { } + @Override public void enterClusterstmt(PostgreSqlParser.ClusterstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitWindow_specification(PostgreSqlParser.Window_specificationContext ctx) { } + @Override public void exitClusterstmt(PostgreSqlParser.ClusterstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterPartition_clause(PostgreSqlParser.Partition_clauseContext ctx) { } + @Override public void enterCluster_index_specification(PostgreSqlParser.Cluster_index_specificationContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitPartition_clause(PostgreSqlParser.Partition_clauseContext ctx) { } + @Override public void exitCluster_index_specification(PostgreSqlParser.Cluster_index_specificationContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterOver_clause(PostgreSqlParser.Over_clauseContext ctx) { } + @Override public void enterVacuumstmt(PostgreSqlParser.VacuumstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitOver_clause(PostgreSqlParser.Over_clauseContext ctx) { } + @Override public void exitVacuumstmt(PostgreSqlParser.VacuumstmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCombine_clause(PostgreSqlParser.Combine_clauseContext ctx) { } + @Override public void enterAnalyzestmt(PostgreSqlParser.AnalyzestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCombine_clause(PostgreSqlParser.Combine_clauseContext ctx) { } + @Override public void exitAnalyzestmt(PostgreSqlParser.AnalyzestmtContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterOrder_by_clause(PostgreSqlParser.Order_by_clauseContext ctx) { } + @Override public void enterVac_analyze_option_list(PostgreSqlParser.Vac_analyze_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitOrder_by_clause(PostgreSqlParser.Order_by_clauseContext ctx) { } + @Override public void exitVac_analyze_option_list(PostgreSqlParser.Vac_analyze_option_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterOrder_by_item(PostgreSqlParser.Order_by_itemContext ctx) { } + @Override public void enterAnalyze_keyword(PostgreSqlParser.Analyze_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitOrder_by_item(PostgreSqlParser.Order_by_itemContext ctx) { } + @Override public void exitAnalyze_keyword(PostgreSqlParser.Analyze_keywordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVac_analyze_option_elem(PostgreSqlParser.Vac_analyze_option_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVac_analyze_option_elem(PostgreSqlParser.Vac_analyze_option_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVac_analyze_option_name(PostgreSqlParser.Vac_analyze_option_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVac_analyze_option_name(PostgreSqlParser.Vac_analyze_option_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVac_analyze_option_arg(PostgreSqlParser.Vac_analyze_option_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVac_analyze_option_arg(PostgreSqlParser.Vac_analyze_option_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_analyze(PostgreSqlParser.Opt_analyzeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_analyze(PostgreSqlParser.Opt_analyzeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_verbose(PostgreSqlParser.Opt_verboseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_verbose(PostgreSqlParser.Opt_verboseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_full(PostgreSqlParser.Opt_fullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_full(PostgreSqlParser.Opt_fullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_freeze(PostgreSqlParser.Opt_freezeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_freeze(PostgreSqlParser.Opt_freezeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_name_list(PostgreSqlParser.Opt_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_name_list(PostgreSqlParser.Opt_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVacuum_relation(PostgreSqlParser.Vacuum_relationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVacuum_relation(PostgreSqlParser.Vacuum_relationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVacuum_relation_list(PostgreSqlParser.Vacuum_relation_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVacuum_relation_list(PostgreSqlParser.Vacuum_relation_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_vacuum_relation_list(PostgreSqlParser.Opt_vacuum_relation_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_vacuum_relation_list(PostgreSqlParser.Opt_vacuum_relation_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplainstmt(PostgreSqlParser.ExplainstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplainstmt(PostgreSqlParser.ExplainstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplainablestmt(PostgreSqlParser.ExplainablestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplainablestmt(PostgreSqlParser.ExplainablestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplain_option_list(PostgreSqlParser.Explain_option_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplain_option_list(PostgreSqlParser.Explain_option_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplain_option_elem(PostgreSqlParser.Explain_option_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplain_option_elem(PostgreSqlParser.Explain_option_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplain_option_name(PostgreSqlParser.Explain_option_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplain_option_name(PostgreSqlParser.Explain_option_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplain_option_arg(PostgreSqlParser.Explain_option_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplain_option_arg(PostgreSqlParser.Explain_option_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPreparestmt(PostgreSqlParser.PreparestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPreparestmt(PostgreSqlParser.PreparestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrep_type_clause(PostgreSqlParser.Prep_type_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrep_type_clause(PostgreSqlParser.Prep_type_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPreparablestmt(PostgreSqlParser.PreparablestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPreparablestmt(PostgreSqlParser.PreparablestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExecutestmt(PostgreSqlParser.ExecutestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExecutestmt(PostgreSqlParser.ExecutestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExecute_param_clause(PostgreSqlParser.Execute_param_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExecute_param_clause(PostgreSqlParser.Execute_param_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeallocatestmt(PostgreSqlParser.DeallocatestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeallocatestmt(PostgreSqlParser.DeallocatestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInsertstmt(PostgreSqlParser.InsertstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInsertstmt(PostgreSqlParser.InsertstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInsert_target(PostgreSqlParser.Insert_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInsert_target(PostgreSqlParser.Insert_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInsert_rest(PostgreSqlParser.Insert_restContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInsert_rest(PostgreSqlParser.Insert_restContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOverride_kind(PostgreSqlParser.Override_kindContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOverride_kind(PostgreSqlParser.Override_kindContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInsert_column_list(PostgreSqlParser.Insert_column_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInsert_column_list(PostgreSqlParser.Insert_column_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInsert_column_item(PostgreSqlParser.Insert_column_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInsert_column_item(PostgreSqlParser.Insert_column_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_on_conflict(PostgreSqlParser.Opt_on_conflictContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_on_conflict(PostgreSqlParser.Opt_on_conflictContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_conf_expr(PostgreSqlParser.Opt_conf_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_conf_expr(PostgreSqlParser.Opt_conf_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterReturning_clause(PostgreSqlParser.Returning_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitReturning_clause(PostgreSqlParser.Returning_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMergestmt(PostgreSqlParser.MergestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMergestmt(PostgreSqlParser.MergestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMerge_insert_clause(PostgreSqlParser.Merge_insert_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMerge_insert_clause(PostgreSqlParser.Merge_insert_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMerge_update_clause(PostgreSqlParser.Merge_update_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMerge_update_clause(PostgreSqlParser.Merge_update_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMerge_delete_clause(PostgreSqlParser.Merge_delete_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMerge_delete_clause(PostgreSqlParser.Merge_delete_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeletestmt(PostgreSqlParser.DeletestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeletestmt(PostgreSqlParser.DeletestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUsing_clause(PostgreSqlParser.Using_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUsing_clause(PostgreSqlParser.Using_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLockstmt(PostgreSqlParser.LockstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLockstmt(PostgreSqlParser.LockstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_lock(PostgreSqlParser.Opt_lockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_lock(PostgreSqlParser.Opt_lockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLock_type(PostgreSqlParser.Lock_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLock_type(PostgreSqlParser.Lock_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_nowait(PostgreSqlParser.Opt_nowaitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_nowait(PostgreSqlParser.Opt_nowaitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_nowait_or_skip(PostgreSqlParser.Opt_nowait_or_skipContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_nowait_or_skip(PostgreSqlParser.Opt_nowait_or_skipContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUpdatestmt(PostgreSqlParser.UpdatestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUpdatestmt(PostgreSqlParser.UpdatestmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSet_clause_list(PostgreSqlParser.Set_clause_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSet_clause_list(PostgreSqlParser.Set_clause_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSet_clause(PostgreSqlParser.Set_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSet_clause(PostgreSqlParser.Set_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSet_target(PostgreSqlParser.Set_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSet_target(PostgreSqlParser.Set_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSet_target_list(PostgreSqlParser.Set_target_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSet_target_list(PostgreSqlParser.Set_target_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDeclarecursorstmt(PostgreSqlParser.DeclarecursorstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDeclarecursorstmt(PostgreSqlParser.DeclarecursorstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCursor_name(PostgreSqlParser.Cursor_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCursor_name(PostgreSqlParser.Cursor_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCursor_options(PostgreSqlParser.Cursor_optionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCursor_options(PostgreSqlParser.Cursor_optionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_hold(PostgreSqlParser.Opt_holdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_hold(PostgreSqlParser.Opt_holdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelectstmt(PostgreSqlParser.SelectstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelectstmt(PostgreSqlParser.SelectstmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelect_with_parens(PostgreSqlParser.Select_with_parensContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelect_with_parens(PostgreSqlParser.Select_with_parensContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelect_no_parens(PostgreSqlParser.Select_no_parensContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelect_no_parens(PostgreSqlParser.Select_no_parensContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelect_clause(PostgreSqlParser.Select_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelect_clause(PostgreSqlParser.Select_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimple_select_intersect(PostgreSqlParser.Simple_select_intersectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimple_select_intersect(PostgreSqlParser.Simple_select_intersectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimple_select_pramary(PostgreSqlParser.Simple_select_pramaryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimple_select_pramary(PostgreSqlParser.Simple_select_pramaryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTop_clause(PostgreSqlParser.Top_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTop_clause(PostgreSqlParser.Top_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWith_clause(PostgreSqlParser.With_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWith_clause(PostgreSqlParser.With_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCte_list(PostgreSqlParser.Cte_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCte_list(PostgreSqlParser.Cte_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCommon_table_expr(PostgreSqlParser.Common_table_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCommon_table_expr(PostgreSqlParser.Common_table_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_materialized(PostgreSqlParser.Opt_materializedContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_materialized(PostgreSqlParser.Opt_materializedContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_with_clause(PostgreSqlParser.Opt_with_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_with_clause(PostgreSqlParser.Opt_with_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInto_clause(PostgreSqlParser.Into_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInto_clause(PostgreSqlParser.Into_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_strict(PostgreSqlParser.Opt_strictContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_strict(PostgreSqlParser.Opt_strictContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpttempTableName(PostgreSqlParser.OpttempTableNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpttempTableName(PostgreSqlParser.OpttempTableNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_table(PostgreSqlParser.Opt_tableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_table(PostgreSqlParser.Opt_tableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAll_or_distinct(PostgreSqlParser.All_or_distinctContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAll_or_distinct(PostgreSqlParser.All_or_distinctContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDistinct_clause(PostgreSqlParser.Distinct_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDistinct_clause(PostgreSqlParser.Distinct_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_all_clause(PostgreSqlParser.Opt_all_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_all_clause(PostgreSqlParser.Opt_all_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_sort_clause(PostgreSqlParser.Opt_sort_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_sort_clause(PostgreSqlParser.Opt_sort_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSort_clause(PostgreSqlParser.Sort_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSort_clause(PostgreSqlParser.Sort_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSortby_list(PostgreSqlParser.Sortby_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSortby_list(PostgreSqlParser.Sortby_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSortby(PostgreSqlParser.SortbyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSortby(PostgreSqlParser.SortbyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelect_limit(PostgreSqlParser.Select_limitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelect_limit(PostgreSqlParser.Select_limitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_select_limit(PostgreSqlParser.Opt_select_limitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_select_limit(PostgreSqlParser.Opt_select_limitContext ctx) { } /** * {@inheritDoc} * @@ -2597,421 +6103,349 @@ public class PostgreSqlParserBaseListener implements PostgreSqlParserListener { * *

The default implementation does nothing.

*/ - @Override public void enterFetch_clause(PostgreSqlParser.Fetch_clauseContext ctx) { } + @Override public void enterSelect_limit_value(PostgreSqlParser.Select_limit_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFetch_clause(PostgreSqlParser.Fetch_clauseContext ctx) { } + @Override public void exitSelect_limit_value(PostgreSqlParser.Select_limit_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFor_clause(PostgreSqlParser.For_clauseContext ctx) { } + @Override public void enterSelect_offset_value(PostgreSqlParser.Select_offset_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFor_clause(PostgreSqlParser.For_clauseContext ctx) { } + @Override public void exitSelect_offset_value(PostgreSqlParser.Select_offset_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterUpdater_clause(PostgreSqlParser.Updater_clauseContext ctx) { } + @Override public void enterSelect_fetch_first_value(PostgreSqlParser.Select_fetch_first_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitUpdater_clause(PostgreSqlParser.Updater_clauseContext ctx) { } + @Override public void exitSelect_fetch_first_value(PostgreSqlParser.Select_fetch_first_valueContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterUpdater_expr(PostgreSqlParser.Updater_exprContext ctx) { } + @Override public void enterI_or_f_const(PostgreSqlParser.I_or_f_constContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitUpdater_expr(PostgreSqlParser.Updater_exprContext ctx) { } + @Override public void exitI_or_f_const(PostgreSqlParser.I_or_f_constContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterReturning_clause(PostgreSqlParser.Returning_clauseContext ctx) { } + @Override public void enterRow_or_rows(PostgreSqlParser.Row_or_rowsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitReturning_clause(PostgreSqlParser.Returning_clauseContext ctx) { } + @Override public void exitRow_or_rows(PostgreSqlParser.Row_or_rowsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterExpr(PostgreSqlParser.ExprContext ctx) { } + @Override public void enterFirst_or_next(PostgreSqlParser.First_or_nextContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitExpr(PostgreSqlParser.ExprContext ctx) { } + @Override public void exitFirst_or_next(PostgreSqlParser.First_or_nextContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterParameter(PostgreSqlParser.ParameterContext ctx) { } + @Override public void enterGroup_clause(PostgreSqlParser.Group_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitParameter(PostgreSqlParser.ParameterContext ctx) { } + @Override public void exitGroup_clause(PostgreSqlParser.Group_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterParameterOrIntegerLiteral(PostgreSqlParser.ParameterOrIntegerLiteralContext ctx) { } + @Override public void enterGroup_by_list(PostgreSqlParser.Group_by_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitParameterOrIntegerLiteral(PostgreSqlParser.ParameterOrIntegerLiteralContext ctx) { } + @Override public void exitGroup_by_list(PostgreSqlParser.Group_by_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterParameterOrNumericLiteral(PostgreSqlParser.ParameterOrNumericLiteralContext ctx) { } + @Override public void enterGroup_by_item(PostgreSqlParser.Group_by_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitParameterOrNumericLiteral(PostgreSqlParser.ParameterOrNumericLiteralContext ctx) { } + @Override public void exitGroup_by_item(PostgreSqlParser.Group_by_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterBool_expr(PostgreSqlParser.Bool_exprContext ctx) { } + @Override public void enterEmpty_grouping_set(PostgreSqlParser.Empty_grouping_setContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitBool_expr(PostgreSqlParser.Bool_exprContext ctx) { } + @Override public void exitEmpty_grouping_set(PostgreSqlParser.Empty_grouping_setContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCase_expr(PostgreSqlParser.Case_exprContext ctx) { } + @Override public void enterRollup_clause(PostgreSqlParser.Rollup_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCase_expr(PostgreSqlParser.Case_exprContext ctx) { } + @Override public void exitRollup_clause(PostgreSqlParser.Rollup_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterExpr_list(PostgreSqlParser.Expr_listContext ctx) { } + @Override public void enterCube_clause(PostgreSqlParser.Cube_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitExpr_list(PostgreSqlParser.Expr_listContext ctx) { } + @Override public void exitCube_clause(PostgreSqlParser.Cube_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterExpr_list_list(PostgreSqlParser.Expr_list_listContext ctx) { } + @Override public void enterGrouping_sets_clause(PostgreSqlParser.Grouping_sets_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitExpr_list_list(PostgreSqlParser.Expr_list_listContext ctx) { } + @Override public void exitGrouping_sets_clause(PostgreSqlParser.Grouping_sets_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFunc_sig_arg(PostgreSqlParser.Func_sig_argContext ctx) { } + @Override public void enterHaving_clause(PostgreSqlParser.Having_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFunc_sig_arg(PostgreSqlParser.Func_sig_argContext ctx) { } + @Override public void exitHaving_clause(PostgreSqlParser.Having_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFunc_sig_arg_list(PostgreSqlParser.Func_sig_arg_listContext ctx) { } + @Override public void enterFor_locking_clause(PostgreSqlParser.For_locking_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFunc_sig_arg_list(PostgreSqlParser.Func_sig_arg_listContext ctx) { } + @Override public void exitFor_locking_clause(PostgreSqlParser.For_locking_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFunc_sig(PostgreSqlParser.Func_sigContext ctx) { } + @Override public void enterOpt_for_locking_clause(PostgreSqlParser.Opt_for_locking_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFunc_sig(PostgreSqlParser.Func_sigContext ctx) { } + @Override public void exitOpt_for_locking_clause(PostgreSqlParser.Opt_for_locking_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterFunc_sig_list(PostgreSqlParser.Func_sig_listContext ctx) { } + @Override public void enterFor_locking_items(PostgreSqlParser.For_locking_itemsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitFunc_sig_list(PostgreSqlParser.Func_sig_listContext ctx) { } + @Override public void exitFor_locking_items(PostgreSqlParser.For_locking_itemsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterType_name(PostgreSqlParser.Type_nameContext ctx) { } + @Override public void enterFor_locking_item(PostgreSqlParser.For_locking_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitType_name(PostgreSqlParser.Type_nameContext ctx) { } + @Override public void exitFor_locking_item(PostgreSqlParser.For_locking_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterTimezone(PostgreSqlParser.TimezoneContext ctx) { } + @Override public void enterFor_locking_strength(PostgreSqlParser.For_locking_strengthContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitTimezone(PostgreSqlParser.TimezoneContext ctx) { } + @Override public void exitFor_locking_strength(PostgreSqlParser.For_locking_strengthContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterOper(PostgreSqlParser.OperContext ctx) { } + @Override public void enterLocked_rels_list(PostgreSqlParser.Locked_rels_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitOper(PostgreSqlParser.OperContext ctx) { } + @Override public void exitLocked_rels_list(PostgreSqlParser.Locked_rels_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAggregate(PostgreSqlParser.AggregateContext ctx) { } + @Override public void enterValues_clause(PostgreSqlParser.Values_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAggregate(PostgreSqlParser.AggregateContext ctx) { } + @Override public void exitValues_clause(PostgreSqlParser.Values_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterName_(PostgreSqlParser.Name_Context ctx) { } + @Override public void enterFrom_clause(PostgreSqlParser.From_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitName_(PostgreSqlParser.Name_Context ctx) { } + @Override public void exitFrom_clause(PostgreSqlParser.From_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterName_list(PostgreSqlParser.Name_listContext ctx) { } + @Override public void enterFrom_list(PostgreSqlParser.From_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitName_list(PostgreSqlParser.Name_listContext ctx) { } + @Override public void exitFrom_list(PostgreSqlParser.From_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterIdentifier_list(PostgreSqlParser.Identifier_listContext ctx) { } + @Override public void enterNon_ansi_join(PostgreSqlParser.Non_ansi_joinContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitIdentifier_list(PostgreSqlParser.Identifier_listContext ctx) { } + @Override public void exitNon_ansi_join(PostgreSqlParser.Non_ansi_joinContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterOption_expr(PostgreSqlParser.Option_exprContext ctx) { } + @Override public void enterTable_ref(PostgreSqlParser.Table_refContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitOption_expr(PostgreSqlParser.Option_exprContext ctx) { } + @Override public void exitTable_ref(PostgreSqlParser.Table_refContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterOption_list(PostgreSqlParser.Option_listContext ctx) { } + @Override public void enterAlias_clause(PostgreSqlParser.Alias_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitOption_list(PostgreSqlParser.Option_listContext ctx) { } + @Override public void exitAlias_clause(PostgreSqlParser.Alias_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterTable_name_(PostgreSqlParser.Table_name_Context ctx) { } + @Override public void enterOpt_alias_clause(PostgreSqlParser.Opt_alias_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitTable_name_(PostgreSqlParser.Table_name_Context ctx) { } + @Override public void exitOpt_alias_clause(PostgreSqlParser.Opt_alias_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterData_type(PostgreSqlParser.Data_typeContext ctx) { } + @Override public void enterTable_alias_clause(PostgreSqlParser.Table_alias_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitData_type(PostgreSqlParser.Data_typeContext ctx) { } + @Override public void exitTable_alias_clause(PostgreSqlParser.Table_alias_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterData_type_list(PostgreSqlParser.Data_type_listContext ctx) { } + @Override public void enterFunc_alias_clause(PostgreSqlParser.Func_alias_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitData_type_list(PostgreSqlParser.Data_type_listContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIndex_method(PostgreSqlParser.Index_methodContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIndex_method(PostgreSqlParser.Index_methodContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunc_name(PostgreSqlParser.Func_nameContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunc_name(PostgreSqlParser.Func_nameContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunc_call(PostgreSqlParser.Func_callContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunc_call(PostgreSqlParser.Func_callContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterArray_cons_expr(PostgreSqlParser.Array_cons_exprContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitArray_cons_expr(PostgreSqlParser.Array_cons_exprContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFrom_item(PostgreSqlParser.From_itemContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFrom_item(PostgreSqlParser.From_itemContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWith_column_alias(PostgreSqlParser.With_column_aliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWith_column_alias(PostgreSqlParser.With_column_aliasContext ctx) { } + @Override public void exitFunc_alias_clause(PostgreSqlParser.Func_alias_clauseContext ctx) { } /** * {@inheritDoc} * @@ -3029,157 +6463,1897 @@ public class PostgreSqlParserBaseListener implements PostgreSqlParserListener { * *

The default implementation does nothing.

*/ - @Override public void enterJoin_clause(PostgreSqlParser.Join_clauseContext ctx) { } + @Override public void enterJoin_qual(PostgreSqlParser.Join_qualContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitJoin_clause(PostgreSqlParser.Join_clauseContext ctx) { } + @Override public void exitJoin_qual(PostgreSqlParser.Join_qualContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterPredicate(PostgreSqlParser.PredicateContext ctx) { } + @Override public void enterRelation_expr(PostgreSqlParser.Relation_exprContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitPredicate(PostgreSqlParser.PredicateContext ctx) { } + @Override public void exitRelation_expr(PostgreSqlParser.Relation_exprContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAggregate_signature(PostgreSqlParser.Aggregate_signatureContext ctx) { } + @Override public void enterRelation_expr_list(PostgreSqlParser.Relation_expr_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAggregate_signature(PostgreSqlParser.Aggregate_signatureContext ctx) { } + @Override public void exitRelation_expr_list(PostgreSqlParser.Relation_expr_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterColumn_constraint(PostgreSqlParser.Column_constraintContext ctx) { } + @Override public void enterRelation_expr_opt_alias(PostgreSqlParser.Relation_expr_opt_aliasContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitColumn_constraint(PostgreSqlParser.Column_constraintContext ctx) { } + @Override public void exitRelation_expr_opt_alias(PostgreSqlParser.Relation_expr_opt_aliasContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterColumn_constraints(PostgreSqlParser.Column_constraintsContext ctx) { } + @Override public void enterTablesample_clause(PostgreSqlParser.Tablesample_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitColumn_constraints(PostgreSqlParser.Column_constraintsContext ctx) { } + @Override public void exitTablesample_clause(PostgreSqlParser.Tablesample_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterIndex_parameters(PostgreSqlParser.Index_parametersContext ctx) { } + @Override public void enterOpt_repeatable_clause(PostgreSqlParser.Opt_repeatable_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitIndex_parameters(PostgreSqlParser.Index_parametersContext ctx) { } + @Override public void exitOpt_repeatable_clause(PostgreSqlParser.Opt_repeatable_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterExclude_element(PostgreSqlParser.Exclude_elementContext ctx) { } + @Override public void enterFunc_table(PostgreSqlParser.Func_tableContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitExclude_element(PostgreSqlParser.Exclude_elementContext ctx) { } + @Override public void exitFunc_table(PostgreSqlParser.Func_tableContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterTable_constraint(PostgreSqlParser.Table_constraintContext ctx) { } + @Override public void enterRowsfrom_item(PostgreSqlParser.Rowsfrom_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitTable_constraint(PostgreSqlParser.Table_constraintContext ctx) { } + @Override public void exitRowsfrom_item(PostgreSqlParser.Rowsfrom_itemContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterRole_name(PostgreSqlParser.Role_nameContext ctx) { } + @Override public void enterRowsfrom_list(PostgreSqlParser.Rowsfrom_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitRole_name(PostgreSqlParser.Role_nameContext ctx) { } + @Override public void exitRowsfrom_list(PostgreSqlParser.Rowsfrom_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterRole_name_list(PostgreSqlParser.Role_name_listContext ctx) { } + @Override public void enterOpt_col_def_list(PostgreSqlParser.Opt_col_def_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitRole_name_list(PostgreSqlParser.Role_name_listContext ctx) { } + @Override public void exitOpt_col_def_list(PostgreSqlParser.Opt_col_def_listContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterParam_value(PostgreSqlParser.Param_valueContext ctx) { } + @Override public void enterOpt_ordinality(PostgreSqlParser.Opt_ordinalityContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitParam_value(PostgreSqlParser.Param_valueContext ctx) { } + @Override public void exitOpt_ordinality(PostgreSqlParser.Opt_ordinalityContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterReserved_keyword(PostgreSqlParser.Reserved_keywordContext ctx) { } + @Override public void enterWhere_clause(PostgreSqlParser.Where_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitReserved_keyword(PostgreSqlParser.Reserved_keywordContext ctx) { } + @Override public void exitWhere_clause(PostgreSqlParser.Where_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterNon_reserved_keyword(PostgreSqlParser.Non_reserved_keywordContext ctx) { } + @Override public void enterWhere_or_current_clause(PostgreSqlParser.Where_or_current_clauseContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitNon_reserved_keyword(PostgreSqlParser.Non_reserved_keywordContext ctx) { } + @Override public void exitWhere_or_current_clause(PostgreSqlParser.Where_or_current_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpttablefuncelementlist(PostgreSqlParser.OpttablefuncelementlistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpttablefuncelementlist(PostgreSqlParser.OpttablefuncelementlistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTablefuncelementlist(PostgreSqlParser.TablefuncelementlistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTablefuncelementlist(PostgreSqlParser.TablefuncelementlistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTablefuncelement(PostgreSqlParser.TablefuncelementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTablefuncelement(PostgreSqlParser.TablefuncelementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXmltable(PostgreSqlParser.XmltableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXmltable(PostgreSqlParser.XmltableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXmltable_column_list(PostgreSqlParser.Xmltable_column_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXmltable_column_list(PostgreSqlParser.Xmltable_column_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXmltable_column_el(PostgreSqlParser.Xmltable_column_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXmltable_column_el(PostgreSqlParser.Xmltable_column_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXmltable_column_option_list(PostgreSqlParser.Xmltable_column_option_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXmltable_column_option_list(PostgreSqlParser.Xmltable_column_option_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXmltable_column_option_el(PostgreSqlParser.Xmltable_column_option_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXmltable_column_option_el(PostgreSqlParser.Xmltable_column_option_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXml_namespace_list(PostgreSqlParser.Xml_namespace_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXml_namespace_list(PostgreSqlParser.Xml_namespace_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXml_namespace_el(PostgreSqlParser.Xml_namespace_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXml_namespace_el(PostgreSqlParser.Xml_namespace_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypename(PostgreSqlParser.TypenameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypename(PostgreSqlParser.TypenameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_array_bounds(PostgreSqlParser.Opt_array_boundsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_array_bounds(PostgreSqlParser.Opt_array_boundsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSimpletypename(PostgreSqlParser.SimpletypenameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSimpletypename(PostgreSqlParser.SimpletypenameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConsttypename(PostgreSqlParser.ConsttypenameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConsttypename(PostgreSqlParser.ConsttypenameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGenerictype(PostgreSqlParser.GenerictypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGenerictype(PostgreSqlParser.GenerictypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_type_modifiers(PostgreSqlParser.Opt_type_modifiersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_type_modifiers(PostgreSqlParser.Opt_type_modifiersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNumeric(PostgreSqlParser.NumericContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNumeric(PostgreSqlParser.NumericContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_float(PostgreSqlParser.Opt_floatContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_float(PostgreSqlParser.Opt_floatContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBit(PostgreSqlParser.BitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBit(PostgreSqlParser.BitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstbit(PostgreSqlParser.ConstbitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstbit(PostgreSqlParser.ConstbitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitwithlength(PostgreSqlParser.BitwithlengthContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitwithlength(PostgreSqlParser.BitwithlengthContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBitwithoutlength(PostgreSqlParser.BitwithoutlengthContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBitwithoutlength(PostgreSqlParser.BitwithoutlengthContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCharacter(PostgreSqlParser.CharacterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCharacter(PostgreSqlParser.CharacterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstcharacter(PostgreSqlParser.ConstcharacterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstcharacter(PostgreSqlParser.ConstcharacterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCharacter_c(PostgreSqlParser.Character_cContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCharacter_c(PostgreSqlParser.Character_cContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_varying(PostgreSqlParser.Opt_varyingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_varying(PostgreSqlParser.Opt_varyingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstdatetime(PostgreSqlParser.ConstdatetimeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstdatetime(PostgreSqlParser.ConstdatetimeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstinterval(PostgreSqlParser.ConstintervalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstinterval(PostgreSqlParser.ConstintervalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_timezone(PostgreSqlParser.Opt_timezoneContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_timezone(PostgreSqlParser.Opt_timezoneContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_interval(PostgreSqlParser.Opt_intervalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_interval(PostgreSqlParser.Opt_intervalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterval_second(PostgreSqlParser.Interval_secondContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterval_second(PostgreSqlParser.Interval_secondContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_escape(PostgreSqlParser.Opt_escapeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_escape(PostgreSqlParser.Opt_escapeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr(PostgreSqlParser.A_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr(PostgreSqlParser.A_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_qual(PostgreSqlParser.A_expr_qualContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_qual(PostgreSqlParser.A_expr_qualContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_lessless(PostgreSqlParser.A_expr_lesslessContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_lessless(PostgreSqlParser.A_expr_lesslessContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_or(PostgreSqlParser.A_expr_orContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_or(PostgreSqlParser.A_expr_orContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_and(PostgreSqlParser.A_expr_andContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_and(PostgreSqlParser.A_expr_andContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_between(PostgreSqlParser.A_expr_betweenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_between(PostgreSqlParser.A_expr_betweenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_in(PostgreSqlParser.A_expr_inContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_in(PostgreSqlParser.A_expr_inContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_unary_not(PostgreSqlParser.A_expr_unary_notContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_unary_not(PostgreSqlParser.A_expr_unary_notContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_isnull(PostgreSqlParser.A_expr_isnullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_isnull(PostgreSqlParser.A_expr_isnullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_is_not(PostgreSqlParser.A_expr_is_notContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_is_not(PostgreSqlParser.A_expr_is_notContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_compare(PostgreSqlParser.A_expr_compareContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_compare(PostgreSqlParser.A_expr_compareContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_like(PostgreSqlParser.A_expr_likeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_like(PostgreSqlParser.A_expr_likeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_qual_op(PostgreSqlParser.A_expr_qual_opContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_qual_op(PostgreSqlParser.A_expr_qual_opContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_unary_qualop(PostgreSqlParser.A_expr_unary_qualopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_unary_qualop(PostgreSqlParser.A_expr_unary_qualopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_add(PostgreSqlParser.A_expr_addContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_add(PostgreSqlParser.A_expr_addContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_mul(PostgreSqlParser.A_expr_mulContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_mul(PostgreSqlParser.A_expr_mulContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_caret(PostgreSqlParser.A_expr_caretContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_caret(PostgreSqlParser.A_expr_caretContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_unary_sign(PostgreSqlParser.A_expr_unary_signContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_unary_sign(PostgreSqlParser.A_expr_unary_signContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_at_time_zone(PostgreSqlParser.A_expr_at_time_zoneContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_at_time_zone(PostgreSqlParser.A_expr_at_time_zoneContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_collate(PostgreSqlParser.A_expr_collateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_collate(PostgreSqlParser.A_expr_collateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterA_expr_typecast(PostgreSqlParser.A_expr_typecastContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitA_expr_typecast(PostgreSqlParser.A_expr_typecastContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterB_expr(PostgreSqlParser.B_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitB_expr(PostgreSqlParser.B_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterC_expr_exists(PostgreSqlParser.C_expr_existsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitC_expr_exists(PostgreSqlParser.C_expr_existsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterC_expr_expr(PostgreSqlParser.C_expr_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitC_expr_expr(PostgreSqlParser.C_expr_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterC_expr_case(PostgreSqlParser.C_expr_caseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitC_expr_case(PostgreSqlParser.C_expr_caseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_application(PostgreSqlParser.Func_applicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_application(PostgreSqlParser.Func_applicationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_expr(PostgreSqlParser.Func_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_expr(PostgreSqlParser.Func_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_expr_windowless(PostgreSqlParser.Func_expr_windowlessContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_expr_windowless(PostgreSqlParser.Func_expr_windowlessContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_expr_common_subexpr(PostgreSqlParser.Func_expr_common_subexprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_expr_common_subexpr(PostgreSqlParser.Func_expr_common_subexprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXml_root_version(PostgreSqlParser.Xml_root_versionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXml_root_version(PostgreSqlParser.Xml_root_versionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_xml_root_standalone(PostgreSqlParser.Opt_xml_root_standaloneContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_xml_root_standalone(PostgreSqlParser.Opt_xml_root_standaloneContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXml_attributes(PostgreSqlParser.Xml_attributesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXml_attributes(PostgreSqlParser.Xml_attributesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXml_attribute_list(PostgreSqlParser.Xml_attribute_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXml_attribute_list(PostgreSqlParser.Xml_attribute_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXml_attribute_el(PostgreSqlParser.Xml_attribute_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXml_attribute_el(PostgreSqlParser.Xml_attribute_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDocument_or_content(PostgreSqlParser.Document_or_contentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDocument_or_content(PostgreSqlParser.Document_or_contentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXml_whitespace_option(PostgreSqlParser.Xml_whitespace_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXml_whitespace_option(PostgreSqlParser.Xml_whitespace_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXmlexists_argument(PostgreSqlParser.Xmlexists_argumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXmlexists_argument(PostgreSqlParser.Xmlexists_argumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXml_passing_mech(PostgreSqlParser.Xml_passing_mechContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXml_passing_mech(PostgreSqlParser.Xml_passing_mechContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWithin_group_clause(PostgreSqlParser.Within_group_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWithin_group_clause(PostgreSqlParser.Within_group_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFilter_clause(PostgreSqlParser.Filter_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFilter_clause(PostgreSqlParser.Filter_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWindow_clause(PostgreSqlParser.Window_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWindow_clause(PostgreSqlParser.Window_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWindow_definition_list(PostgreSqlParser.Window_definition_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWindow_definition_list(PostgreSqlParser.Window_definition_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWindow_definition(PostgreSqlParser.Window_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWindow_definition(PostgreSqlParser.Window_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOver_clause(PostgreSqlParser.Over_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOver_clause(PostgreSqlParser.Over_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWindow_specification(PostgreSqlParser.Window_specificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWindow_specification(PostgreSqlParser.Window_specificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_existing_window_name(PostgreSqlParser.Opt_existing_window_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_existing_window_name(PostgreSqlParser.Opt_existing_window_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_partition_clause(PostgreSqlParser.Opt_partition_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_partition_clause(PostgreSqlParser.Opt_partition_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_frame_clause(PostgreSqlParser.Opt_frame_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_frame_clause(PostgreSqlParser.Opt_frame_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrame_extent(PostgreSqlParser.Frame_extentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrame_extent(PostgreSqlParser.Frame_extentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrame_bound(PostgreSqlParser.Frame_boundContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrame_bound(PostgreSqlParser.Frame_boundContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_window_exclusion_clause(PostgreSqlParser.Opt_window_exclusion_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_window_exclusion_clause(PostgreSqlParser.Opt_window_exclusion_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRow(PostgreSqlParser.RowContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRow(PostgreSqlParser.RowContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplicit_row(PostgreSqlParser.Explicit_rowContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplicit_row(PostgreSqlParser.Explicit_rowContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImplicit_row(PostgreSqlParser.Implicit_rowContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImplicit_row(PostgreSqlParser.Implicit_rowContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSub_type(PostgreSqlParser.Sub_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSub_type(PostgreSqlParser.Sub_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAll_op(PostgreSqlParser.All_opContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAll_op(PostgreSqlParser.All_opContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMathop(PostgreSqlParser.MathopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMathop(PostgreSqlParser.MathopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQual_op(PostgreSqlParser.Qual_opContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQual_op(PostgreSqlParser.Qual_opContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQual_all_op(PostgreSqlParser.Qual_all_opContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQual_all_op(PostgreSqlParser.Qual_all_opContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubquery_Op(PostgreSqlParser.Subquery_OpContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubquery_Op(PostgreSqlParser.Subquery_OpContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpr_list(PostgreSqlParser.Expr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpr_list(PostgreSqlParser.Expr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_arg_list(PostgreSqlParser.Func_arg_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_arg_list(PostgreSqlParser.Func_arg_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_arg_expr(PostgreSqlParser.Func_arg_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_arg_expr(PostgreSqlParser.Func_arg_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_list(PostgreSqlParser.Type_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_list(PostgreSqlParser.Type_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArray_expr(PostgreSqlParser.Array_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArray_expr(PostgreSqlParser.Array_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArray_expr_list(PostgreSqlParser.Array_expr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArray_expr_list(PostgreSqlParser.Array_expr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExtract_list(PostgreSqlParser.Extract_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExtract_list(PostgreSqlParser.Extract_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExtract_arg(PostgreSqlParser.Extract_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExtract_arg(PostgreSqlParser.Extract_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnicode_normal_form(PostgreSqlParser.Unicode_normal_formContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnicode_normal_form(PostgreSqlParser.Unicode_normal_formContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOverlay_list(PostgreSqlParser.Overlay_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOverlay_list(PostgreSqlParser.Overlay_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPosition_list(PostgreSqlParser.Position_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPosition_list(PostgreSqlParser.Position_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSubstr_list(PostgreSqlParser.Substr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSubstr_list(PostgreSqlParser.Substr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTrim_list(PostgreSqlParser.Trim_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTrim_list(PostgreSqlParser.Trim_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIn_expr_select(PostgreSqlParser.In_expr_selectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIn_expr_select(PostgreSqlParser.In_expr_selectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIn_expr_list(PostgreSqlParser.In_expr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIn_expr_list(PostgreSqlParser.In_expr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCase_expr(PostgreSqlParser.Case_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCase_expr(PostgreSqlParser.Case_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWhen_clause_list(PostgreSqlParser.When_clause_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWhen_clause_list(PostgreSqlParser.When_clause_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWhen_clause(PostgreSqlParser.When_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWhen_clause(PostgreSqlParser.When_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCase_default(PostgreSqlParser.Case_defaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCase_default(PostgreSqlParser.Case_defaultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCase_arg(PostgreSqlParser.Case_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCase_arg(PostgreSqlParser.Case_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumnref(PostgreSqlParser.ColumnrefContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumnref(PostgreSqlParser.ColumnrefContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndirection_el(PostgreSqlParser.Indirection_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndirection_el(PostgreSqlParser.Indirection_elContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_slice_bound(PostgreSqlParser.Opt_slice_boundContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_slice_bound(PostgreSqlParser.Opt_slice_boundContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndirection(PostgreSqlParser.IndirectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndirection(PostgreSqlParser.IndirectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_indirection(PostgreSqlParser.Opt_indirectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_indirection(PostgreSqlParser.Opt_indirectionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_target_list(PostgreSqlParser.Opt_target_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_target_list(PostgreSqlParser.Opt_target_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTarget_list(PostgreSqlParser.Target_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTarget_list(PostgreSqlParser.Target_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTarget_label(PostgreSqlParser.Target_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTarget_label(PostgreSqlParser.Target_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTarget_star(PostgreSqlParser.Target_starContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTarget_star(PostgreSqlParser.Target_starContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQualified_name_list(PostgreSqlParser.Qualified_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQualified_name_list(PostgreSqlParser.Qualified_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQualified_name(PostgreSqlParser.Qualified_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQualified_name(PostgreSqlParser.Qualified_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterName_list(PostgreSqlParser.Name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitName_list(PostgreSqlParser.Name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterName(PostgreSqlParser.NameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitName(PostgreSqlParser.NameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAttr_name(PostgreSqlParser.Attr_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAttr_name(PostgreSqlParser.Attr_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFile_name(PostgreSqlParser.File_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFile_name(PostgreSqlParser.File_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_name(PostgreSqlParser.Func_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_name(PostgreSqlParser.Func_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAexprconst(PostgreSqlParser.AexprconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAexprconst(PostgreSqlParser.AexprconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterXconst(PostgreSqlParser.XconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitXconst(PostgreSqlParser.XconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBconst(PostgreSqlParser.BconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBconst(PostgreSqlParser.BconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFconst(PostgreSqlParser.FconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFconst(PostgreSqlParser.FconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIconst(PostgreSqlParser.IconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIconst(PostgreSqlParser.IconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSconst(PostgreSqlParser.SconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSconst(PostgreSqlParser.SconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnysconst(PostgreSqlParser.AnysconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnysconst(PostgreSqlParser.AnysconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_uescape(PostgreSqlParser.Opt_uescapeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_uescape(PostgreSqlParser.Opt_uescapeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSignediconst(PostgreSqlParser.SignediconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSignediconst(PostgreSqlParser.SignediconstContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRoleid(PostgreSqlParser.RoleidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRoleid(PostgreSqlParser.RoleidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRolespec(PostgreSqlParser.RolespecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRolespec(PostgreSqlParser.RolespecContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRole_list(PostgreSqlParser.Role_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRole_list(PostgreSqlParser.Role_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColid(PostgreSqlParser.ColidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColid(PostgreSqlParser.ColidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTable_alias(PostgreSqlParser.Table_aliasContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTable_alias(PostgreSqlParser.Table_aliasContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_function_name(PostgreSqlParser.Type_function_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_function_name(PostgreSqlParser.Type_function_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNonreservedword(PostgreSqlParser.NonreservedwordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNonreservedword(PostgreSqlParser.NonreservedwordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCollabel(PostgreSqlParser.CollabelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCollabel(PostgreSqlParser.CollabelContext ctx) { } /** * {@inheritDoc} * @@ -3197,97 +8371,1453 @@ public class PostgreSqlParserBaseListener implements PostgreSqlParserListener { * *

The default implementation does nothing.

*/ - @Override public void enterTodo_fill_in(PostgreSqlParser.Todo_fill_inContext ctx) { } + @Override public void enterPlsqlidentifier(PostgreSqlParser.PlsqlidentifierContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitTodo_fill_in(PostgreSqlParser.Todo_fill_inContext ctx) { } + @Override public void exitPlsqlidentifier(PostgreSqlParser.PlsqlidentifierContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterTodo_implement(PostgreSqlParser.Todo_implementContext ctx) { } + @Override public void enterUnreserved_keyword(PostgreSqlParser.Unreserved_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitTodo_implement(PostgreSqlParser.Todo_implementContext ctx) { } + @Override public void exitUnreserved_keyword(PostgreSqlParser.Unreserved_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterCorrelation_name(PostgreSqlParser.Correlation_nameContext ctx) { } + @Override public void enterCol_name_keyword(PostgreSqlParser.Col_name_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitCorrelation_name(PostgreSqlParser.Correlation_nameContext ctx) { } + @Override public void exitCol_name_keyword(PostgreSqlParser.Col_name_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterColumn_name(PostgreSqlParser.Column_nameContext ctx) { } + @Override public void enterType_func_name_keyword(PostgreSqlParser.Type_func_name_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitColumn_name(PostgreSqlParser.Column_nameContext ctx) { } + @Override public void exitType_func_name_keyword(PostgreSqlParser.Type_func_name_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterAlias(PostgreSqlParser.AliasContext ctx) { } + @Override public void enterReserved_keyword(PostgreSqlParser.Reserved_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitAlias(PostgreSqlParser.AliasContext ctx) { } + @Override public void exitReserved_keyword(PostgreSqlParser.Reserved_keywordContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterColumn_alias(PostgreSqlParser.Column_aliasContext ctx) { } + @Override public void enterBuiltin_function_name(PostgreSqlParser.Builtin_function_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitColumn_alias(PostgreSqlParser.Column_aliasContext ctx) { } + @Override public void exitBuiltin_function_name(PostgreSqlParser.Builtin_function_nameContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterColumn_definition(PostgreSqlParser.Column_definitionContext ctx) { } + @Override public void enterPl_function(PostgreSqlParser.Pl_functionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitColumn_definition(PostgreSqlParser.Column_definitionContext ctx) { } + @Override public void exitPl_function(PostgreSqlParser.Pl_functionContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void enterWindow_name(PostgreSqlParser.Window_nameContext ctx) { } + @Override public void enterComp_options(PostgreSqlParser.Comp_optionsContext ctx) { } /** * {@inheritDoc} * *

The default implementation does nothing.

*/ - @Override public void exitWindow_name(PostgreSqlParser.Window_nameContext ctx) { } + @Override public void exitComp_options(PostgreSqlParser.Comp_optionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterComp_option(PostgreSqlParser.Comp_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitComp_option(PostgreSqlParser.Comp_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSharp(PostgreSqlParser.SharpContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSharp(PostgreSqlParser.SharpContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOption_value(PostgreSqlParser.Option_valueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOption_value(PostgreSqlParser.Option_valueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_semi(PostgreSqlParser.Opt_semiContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_semi(PostgreSqlParser.Opt_semiContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPl_block(PostgreSqlParser.Pl_blockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPl_block(PostgreSqlParser.Pl_blockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_sect(PostgreSqlParser.Decl_sectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_sect(PostgreSqlParser.Decl_sectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_start(PostgreSqlParser.Decl_startContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_start(PostgreSqlParser.Decl_startContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_stmts(PostgreSqlParser.Decl_stmtsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_stmts(PostgreSqlParser.Decl_stmtsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLabel_decl(PostgreSqlParser.Label_declContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLabel_decl(PostgreSqlParser.Label_declContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_stmt(PostgreSqlParser.Decl_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_stmt(PostgreSqlParser.Decl_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_statement(PostgreSqlParser.Decl_statementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_statement(PostgreSqlParser.Decl_statementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_scrollable(PostgreSqlParser.Opt_scrollableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_scrollable(PostgreSqlParser.Opt_scrollableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_cursor_query(PostgreSqlParser.Decl_cursor_queryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_cursor_query(PostgreSqlParser.Decl_cursor_queryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_cursor_args(PostgreSqlParser.Decl_cursor_argsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_cursor_args(PostgreSqlParser.Decl_cursor_argsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_cursor_arglist(PostgreSqlParser.Decl_cursor_arglistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_cursor_arglist(PostgreSqlParser.Decl_cursor_arglistContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_cursor_arg(PostgreSqlParser.Decl_cursor_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_cursor_arg(PostgreSqlParser.Decl_cursor_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_is_for(PostgreSqlParser.Decl_is_forContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_is_for(PostgreSqlParser.Decl_is_forContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_aliasitem(PostgreSqlParser.Decl_aliasitemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_aliasitem(PostgreSqlParser.Decl_aliasitemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_varname(PostgreSqlParser.Decl_varnameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_varname(PostgreSqlParser.Decl_varnameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_const(PostgreSqlParser.Decl_constContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_const(PostgreSqlParser.Decl_constContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_datatype(PostgreSqlParser.Decl_datatypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_datatype(PostgreSqlParser.Decl_datatypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_collate(PostgreSqlParser.Decl_collateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_collate(PostgreSqlParser.Decl_collateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_notnull(PostgreSqlParser.Decl_notnullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_notnull(PostgreSqlParser.Decl_notnullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_defval(PostgreSqlParser.Decl_defvalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_defval(PostgreSqlParser.Decl_defvalContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDecl_defkey(PostgreSqlParser.Decl_defkeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDecl_defkey(PostgreSqlParser.Decl_defkeyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAssign_operator(PostgreSqlParser.Assign_operatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAssign_operator(PostgreSqlParser.Assign_operatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProc_sect(PostgreSqlParser.Proc_sectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProc_sect(PostgreSqlParser.Proc_sectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProc_stmt(PostgreSqlParser.Proc_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProc_stmt(PostgreSqlParser.Proc_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_perform(PostgreSqlParser.Stmt_performContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_perform(PostgreSqlParser.Stmt_performContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_call(PostgreSqlParser.Stmt_callContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_call(PostgreSqlParser.Stmt_callContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_expr_list(PostgreSqlParser.Opt_expr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_expr_list(PostgreSqlParser.Opt_expr_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_assign(PostgreSqlParser.Stmt_assignContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_assign(PostgreSqlParser.Stmt_assignContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_getdiag(PostgreSqlParser.Stmt_getdiagContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_getdiag(PostgreSqlParser.Stmt_getdiagContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetdiag_area_opt(PostgreSqlParser.Getdiag_area_optContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetdiag_area_opt(PostgreSqlParser.Getdiag_area_optContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetdiag_list(PostgreSqlParser.Getdiag_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetdiag_list(PostgreSqlParser.Getdiag_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetdiag_list_item(PostgreSqlParser.Getdiag_list_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetdiag_list_item(PostgreSqlParser.Getdiag_list_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetdiag_item(PostgreSqlParser.Getdiag_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetdiag_item(PostgreSqlParser.Getdiag_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGetdiag_target(PostgreSqlParser.Getdiag_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGetdiag_target(PostgreSqlParser.Getdiag_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAssign_var(PostgreSqlParser.Assign_varContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAssign_var(PostgreSqlParser.Assign_varContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_if(PostgreSqlParser.Stmt_ifContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_if(PostgreSqlParser.Stmt_ifContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_elsifs(PostgreSqlParser.Stmt_elsifsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_elsifs(PostgreSqlParser.Stmt_elsifsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_else(PostgreSqlParser.Stmt_elseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_else(PostgreSqlParser.Stmt_elseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_case(PostgreSqlParser.Stmt_caseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_case(PostgreSqlParser.Stmt_caseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_expr_until_when(PostgreSqlParser.Opt_expr_until_whenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_expr_until_when(PostgreSqlParser.Opt_expr_until_whenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCase_when_list(PostgreSqlParser.Case_when_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCase_when_list(PostgreSqlParser.Case_when_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCase_when(PostgreSqlParser.Case_whenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCase_when(PostgreSqlParser.Case_whenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_case_else(PostgreSqlParser.Opt_case_elseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_case_else(PostgreSqlParser.Opt_case_elseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_loop(PostgreSqlParser.Stmt_loopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_loop(PostgreSqlParser.Stmt_loopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_while(PostgreSqlParser.Stmt_whileContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_while(PostgreSqlParser.Stmt_whileContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_for(PostgreSqlParser.Stmt_forContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_for(PostgreSqlParser.Stmt_forContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFor_control(PostgreSqlParser.For_controlContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFor_control(PostgreSqlParser.For_controlContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_for_using_expression(PostgreSqlParser.Opt_for_using_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_for_using_expression(PostgreSqlParser.Opt_for_using_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_cursor_parameters(PostgreSqlParser.Opt_cursor_parametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_cursor_parameters(PostgreSqlParser.Opt_cursor_parametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_reverse(PostgreSqlParser.Opt_reverseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_reverse(PostgreSqlParser.Opt_reverseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_by_expression(PostgreSqlParser.Opt_by_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_by_expression(PostgreSqlParser.Opt_by_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFor_variable(PostgreSqlParser.For_variableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFor_variable(PostgreSqlParser.For_variableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_foreach_a(PostgreSqlParser.Stmt_foreach_aContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_foreach_a(PostgreSqlParser.Stmt_foreach_aContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForeach_slice(PostgreSqlParser.Foreach_sliceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForeach_slice(PostgreSqlParser.Foreach_sliceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_exit(PostgreSqlParser.Stmt_exitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_exit(PostgreSqlParser.Stmt_exitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExit_type(PostgreSqlParser.Exit_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExit_type(PostgreSqlParser.Exit_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_return(PostgreSqlParser.Stmt_returnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_return(PostgreSqlParser.Stmt_returnContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_return_result(PostgreSqlParser.Opt_return_resultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_return_result(PostgreSqlParser.Opt_return_resultContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_raise(PostgreSqlParser.Stmt_raiseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_raise(PostgreSqlParser.Stmt_raiseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_stmt_raise_level(PostgreSqlParser.Opt_stmt_raise_levelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_stmt_raise_level(PostgreSqlParser.Opt_stmt_raise_levelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_raise_list(PostgreSqlParser.Opt_raise_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_raise_list(PostgreSqlParser.Opt_raise_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_raise_using(PostgreSqlParser.Opt_raise_usingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_raise_using(PostgreSqlParser.Opt_raise_usingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_raise_using_elem(PostgreSqlParser.Opt_raise_using_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_raise_using_elem(PostgreSqlParser.Opt_raise_using_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_raise_using_elem_list(PostgreSqlParser.Opt_raise_using_elem_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_raise_using_elem_list(PostgreSqlParser.Opt_raise_using_elem_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_assert(PostgreSqlParser.Stmt_assertContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_assert(PostgreSqlParser.Stmt_assertContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_stmt_assert_message(PostgreSqlParser.Opt_stmt_assert_messageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_stmt_assert_message(PostgreSqlParser.Opt_stmt_assert_messageContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLoop_body(PostgreSqlParser.Loop_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLoop_body(PostgreSqlParser.Loop_bodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_execsql(PostgreSqlParser.Stmt_execsqlContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_execsql(PostgreSqlParser.Stmt_execsqlContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_dynexecute(PostgreSqlParser.Stmt_dynexecuteContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_dynexecute(PostgreSqlParser.Stmt_dynexecuteContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_execute_using(PostgreSqlParser.Opt_execute_usingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_execute_using(PostgreSqlParser.Opt_execute_usingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_execute_using_list(PostgreSqlParser.Opt_execute_using_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_execute_using_list(PostgreSqlParser.Opt_execute_using_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_execute_into(PostgreSqlParser.Opt_execute_intoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_execute_into(PostgreSqlParser.Opt_execute_intoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_open(PostgreSqlParser.Stmt_openContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_open(PostgreSqlParser.Stmt_openContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_open_bound_list_item(PostgreSqlParser.Opt_open_bound_list_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_open_bound_list_item(PostgreSqlParser.Opt_open_bound_list_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_open_bound_list(PostgreSqlParser.Opt_open_bound_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_open_bound_list(PostgreSqlParser.Opt_open_bound_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_open_using(PostgreSqlParser.Opt_open_usingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_open_using(PostgreSqlParser.Opt_open_usingContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_scroll_option(PostgreSqlParser.Opt_scroll_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_scroll_option(PostgreSqlParser.Opt_scroll_optionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_scroll_option_no(PostgreSqlParser.Opt_scroll_option_noContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_scroll_option_no(PostgreSqlParser.Opt_scroll_option_noContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_fetch(PostgreSqlParser.Stmt_fetchContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_fetch(PostgreSqlParser.Stmt_fetchContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInto_target(PostgreSqlParser.Into_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInto_target(PostgreSqlParser.Into_targetContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_cursor_from(PostgreSqlParser.Opt_cursor_fromContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_cursor_from(PostgreSqlParser.Opt_cursor_fromContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_fetch_direction(PostgreSqlParser.Opt_fetch_directionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_fetch_direction(PostgreSqlParser.Opt_fetch_directionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_move(PostgreSqlParser.Stmt_moveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_move(PostgreSqlParser.Stmt_moveContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_close(PostgreSqlParser.Stmt_closeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_close(PostgreSqlParser.Stmt_closeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_null(PostgreSqlParser.Stmt_nullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_null(PostgreSqlParser.Stmt_nullContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_commit(PostgreSqlParser.Stmt_commitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_commit(PostgreSqlParser.Stmt_commitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_rollback(PostgreSqlParser.Stmt_rollbackContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_rollback(PostgreSqlParser.Stmt_rollbackContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPlsql_opt_transaction_chain(PostgreSqlParser.Plsql_opt_transaction_chainContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPlsql_opt_transaction_chain(PostgreSqlParser.Plsql_opt_transaction_chainContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStmt_set(PostgreSqlParser.Stmt_setContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt_set(PostgreSqlParser.Stmt_setContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCursor_variable(PostgreSqlParser.Cursor_variableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCursor_variable(PostgreSqlParser.Cursor_variableContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterException_sect(PostgreSqlParser.Exception_sectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitException_sect(PostgreSqlParser.Exception_sectContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProc_exceptions(PostgreSqlParser.Proc_exceptionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProc_exceptions(PostgreSqlParser.Proc_exceptionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProc_exception(PostgreSqlParser.Proc_exceptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProc_exception(PostgreSqlParser.Proc_exceptionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProc_conditions(PostgreSqlParser.Proc_conditionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProc_conditions(PostgreSqlParser.Proc_conditionsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterProc_condition(PostgreSqlParser.Proc_conditionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitProc_condition(PostgreSqlParser.Proc_conditionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_block_label(PostgreSqlParser.Opt_block_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_block_label(PostgreSqlParser.Opt_block_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_loop_label(PostgreSqlParser.Opt_loop_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_loop_label(PostgreSqlParser.Opt_loop_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_label(PostgreSqlParser.Opt_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_label(PostgreSqlParser.Opt_labelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_exitcond(PostgreSqlParser.Opt_exitcondContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_exitcond(PostgreSqlParser.Opt_exitcondContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAny_identifier(PostgreSqlParser.Any_identifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAny_identifier(PostgreSqlParser.Any_identifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPlsql_unreserved_keyword(PostgreSqlParser.Plsql_unreserved_keywordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPlsql_unreserved_keyword(PostgreSqlParser.Plsql_unreserved_keywordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSql_expression(PostgreSqlParser.Sql_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSql_expression(PostgreSqlParser.Sql_expressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpr_until_then(PostgreSqlParser.Expr_until_thenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpr_until_then(PostgreSqlParser.Expr_until_thenContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpr_until_semi(PostgreSqlParser.Expr_until_semiContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpr_until_semi(PostgreSqlParser.Expr_until_semiContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpr_until_rightbracket(PostgreSqlParser.Expr_until_rightbracketContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpr_until_rightbracket(PostgreSqlParser.Expr_until_rightbracketContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpr_until_loop(PostgreSqlParser.Expr_until_loopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpr_until_loop(PostgreSqlParser.Expr_until_loopContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMake_execsql_stmt(PostgreSqlParser.Make_execsql_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMake_execsql_stmt(PostgreSqlParser.Make_execsql_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOpt_returning_clause_into(PostgreSqlParser.Opt_returning_clause_intoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOpt_returning_clause_into(PostgreSqlParser.Opt_returning_clause_intoContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParameter(PostgreSqlParser.ParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParameter(PostgreSqlParser.ParameterContext ctx) { } /** * {@inheritDoc} diff --git a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserListener.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserListener.java index 3f5da6a34..69e83af19 100644 --- a/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserListener.java +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserListener.java @@ -1,5 +1,7 @@ // Generated from PostgreSqlParser.g4 by ANTLR 4.13.1 package org.springframework.ide.vscode.parser.postgresql; + + import org.antlr.v4.runtime.tree.ParseTreeListener; /** @@ -17,6 +19,36 @@ public interface PostgreSqlParserListener extends ParseTreeListener { * @param ctx the parse tree */ void exitRoot(PostgreSqlParser.RootContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#plsqlroot}. + * @param ctx the parse tree + */ + void enterPlsqlroot(PostgreSqlParser.PlsqlrootContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#plsqlroot}. + * @param ctx the parse tree + */ + void exitPlsqlroot(PostgreSqlParser.PlsqlrootContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmtblock}. + * @param ctx the parse tree + */ + void enterStmtblock(PostgreSqlParser.StmtblockContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmtblock}. + * @param ctx the parse tree + */ + void exitStmtblock(PostgreSqlParser.StmtblockContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmtmulti}. + * @param ctx the parse tree + */ + void enterStmtmulti(PostgreSqlParser.StmtmultiContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmtmulti}. + * @param ctx the parse tree + */ + void exitStmtmulti(PostgreSqlParser.StmtmultiContext ctx); /** * Enter a parse tree produced by {@link PostgreSqlParser#stmt}. * @param ctx the parse tree @@ -28,1795 +60,3915 @@ public interface PostgreSqlParserListener extends ParseTreeListener { */ void exitStmt(PostgreSqlParser.StmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#abort_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#plsqlconsolecommand}. * @param ctx the parse tree */ - void enterAbort_stmt(PostgreSqlParser.Abort_stmtContext ctx); + void enterPlsqlconsolecommand(PostgreSqlParser.PlsqlconsolecommandContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#abort_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#plsqlconsolecommand}. * @param ctx the parse tree */ - void exitAbort_stmt(PostgreSqlParser.Abort_stmtContext ctx); + void exitPlsqlconsolecommand(PostgreSqlParser.PlsqlconsolecommandContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#callstmt}. * @param ctx the parse tree */ - void enterAlter_stmt(PostgreSqlParser.Alter_stmtContext ctx); + void enterCallstmt(PostgreSqlParser.CallstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#callstmt}. * @param ctx the parse tree */ - void exitAlter_stmt(PostgreSqlParser.Alter_stmtContext ctx); + void exitCallstmt(PostgreSqlParser.CallstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_aggregate_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createrolestmt}. * @param ctx the parse tree */ - void enterAlter_aggregate_stmt(PostgreSqlParser.Alter_aggregate_stmtContext ctx); + void enterCreaterolestmt(PostgreSqlParser.CreaterolestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_aggregate_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createrolestmt}. * @param ctx the parse tree */ - void exitAlter_aggregate_stmt(PostgreSqlParser.Alter_aggregate_stmtContext ctx); + void exitCreaterolestmt(PostgreSqlParser.CreaterolestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_collation_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_with}. * @param ctx the parse tree */ - void enterAlter_collation_stmt(PostgreSqlParser.Alter_collation_stmtContext ctx); + void enterOpt_with(PostgreSqlParser.Opt_withContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_collation_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_with}. * @param ctx the parse tree */ - void exitAlter_collation_stmt(PostgreSqlParser.Alter_collation_stmtContext ctx); + void exitOpt_with(PostgreSqlParser.Opt_withContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_conversion_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optrolelist}. * @param ctx the parse tree */ - void enterAlter_conversion_stmt(PostgreSqlParser.Alter_conversion_stmtContext ctx); + void enterOptrolelist(PostgreSqlParser.OptrolelistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_conversion_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optrolelist}. * @param ctx the parse tree */ - void exitAlter_conversion_stmt(PostgreSqlParser.Alter_conversion_stmtContext ctx); + void exitOptrolelist(PostgreSqlParser.OptrolelistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_database_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alteroptrolelist}. * @param ctx the parse tree */ - void enterAlter_database_stmt(PostgreSqlParser.Alter_database_stmtContext ctx); + void enterAlteroptrolelist(PostgreSqlParser.AlteroptrolelistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_database_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alteroptrolelist}. * @param ctx the parse tree */ - void exitAlter_database_stmt(PostgreSqlParser.Alter_database_stmtContext ctx); + void exitAlteroptrolelist(PostgreSqlParser.AlteroptrolelistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_default_privileges_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alteroptroleelem}. * @param ctx the parse tree */ - void enterAlter_default_privileges_stmt(PostgreSqlParser.Alter_default_privileges_stmtContext ctx); + void enterAlteroptroleelem(PostgreSqlParser.AlteroptroleelemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_default_privileges_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alteroptroleelem}. * @param ctx the parse tree */ - void exitAlter_default_privileges_stmt(PostgreSqlParser.Alter_default_privileges_stmtContext ctx); + void exitAlteroptroleelem(PostgreSqlParser.AlteroptroleelemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_domain_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createoptroleelem}. * @param ctx the parse tree */ - void enterAlter_domain_stmt(PostgreSqlParser.Alter_domain_stmtContext ctx); + void enterCreateoptroleelem(PostgreSqlParser.CreateoptroleelemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_domain_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createoptroleelem}. * @param ctx the parse tree */ - void exitAlter_domain_stmt(PostgreSqlParser.Alter_domain_stmtContext ctx); + void exitCreateoptroleelem(PostgreSqlParser.CreateoptroleelemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_event_trigger_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createuserstmt}. * @param ctx the parse tree */ - void enterAlter_event_trigger_stmt(PostgreSqlParser.Alter_event_trigger_stmtContext ctx); + void enterCreateuserstmt(PostgreSqlParser.CreateuserstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_event_trigger_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createuserstmt}. * @param ctx the parse tree */ - void exitAlter_event_trigger_stmt(PostgreSqlParser.Alter_event_trigger_stmtContext ctx); + void exitCreateuserstmt(PostgreSqlParser.CreateuserstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_extension_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterrolestmt}. * @param ctx the parse tree */ - void enterAlter_extension_stmt(PostgreSqlParser.Alter_extension_stmtContext ctx); + void enterAlterrolestmt(PostgreSqlParser.AlterrolestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_extension_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterrolestmt}. * @param ctx the parse tree */ - void exitAlter_extension_stmt(PostgreSqlParser.Alter_extension_stmtContext ctx); + void exitAlterrolestmt(PostgreSqlParser.AlterrolestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_foreign_data_wrapper_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_in_database}. * @param ctx the parse tree */ - void enterAlter_foreign_data_wrapper_stmt(PostgreSqlParser.Alter_foreign_data_wrapper_stmtContext ctx); + void enterOpt_in_database(PostgreSqlParser.Opt_in_databaseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_foreign_data_wrapper_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_in_database}. * @param ctx the parse tree */ - void exitAlter_foreign_data_wrapper_stmt(PostgreSqlParser.Alter_foreign_data_wrapper_stmtContext ctx); + void exitOpt_in_database(PostgreSqlParser.Opt_in_databaseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_action}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterrolesetstmt}. * @param ctx the parse tree */ - void enterAlter_foreign_table_action(PostgreSqlParser.Alter_foreign_table_actionContext ctx); + void enterAlterrolesetstmt(PostgreSqlParser.AlterrolesetstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_action}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterrolesetstmt}. * @param ctx the parse tree */ - void exitAlter_foreign_table_action(PostgreSqlParser.Alter_foreign_table_actionContext ctx); + void exitAlterrolesetstmt(PostgreSqlParser.AlterrolesetstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_action_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#droprolestmt}. * @param ctx the parse tree */ - void enterAlter_foreign_table_action_list(PostgreSqlParser.Alter_foreign_table_action_listContext ctx); + void enterDroprolestmt(PostgreSqlParser.DroprolestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_action_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#droprolestmt}. * @param ctx the parse tree */ - void exitAlter_foreign_table_action_list(PostgreSqlParser.Alter_foreign_table_action_listContext ctx); + void exitDroprolestmt(PostgreSqlParser.DroprolestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#creategroupstmt}. * @param ctx the parse tree */ - void enterAlter_foreign_table_stmt(PostgreSqlParser.Alter_foreign_table_stmtContext ctx); + void enterCreategroupstmt(PostgreSqlParser.CreategroupstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#creategroupstmt}. * @param ctx the parse tree */ - void exitAlter_foreign_table_stmt(PostgreSqlParser.Alter_foreign_table_stmtContext ctx); + void exitCreategroupstmt(PostgreSqlParser.CreategroupstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_function_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#altergroupstmt}. * @param ctx the parse tree */ - void enterAlter_function_stmt(PostgreSqlParser.Alter_function_stmtContext ctx); + void enterAltergroupstmt(PostgreSqlParser.AltergroupstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_function_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#altergroupstmt}. * @param ctx the parse tree */ - void exitAlter_function_stmt(PostgreSqlParser.Alter_function_stmtContext ctx); + void exitAltergroupstmt(PostgreSqlParser.AltergroupstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_group_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#add_drop}. * @param ctx the parse tree */ - void enterAlter_group_stmt(PostgreSqlParser.Alter_group_stmtContext ctx); + void enterAdd_drop(PostgreSqlParser.Add_dropContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_group_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#add_drop}. * @param ctx the parse tree */ - void exitAlter_group_stmt(PostgreSqlParser.Alter_group_stmtContext ctx); + void exitAdd_drop(PostgreSqlParser.Add_dropContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_index_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createschemastmt}. * @param ctx the parse tree */ - void enterAlter_index_stmt(PostgreSqlParser.Alter_index_stmtContext ctx); + void enterCreateschemastmt(PostgreSqlParser.CreateschemastmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_index_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createschemastmt}. * @param ctx the parse tree */ - void exitAlter_index_stmt(PostgreSqlParser.Alter_index_stmtContext ctx); + void exitCreateschemastmt(PostgreSqlParser.CreateschemastmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_language_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optschemaname}. * @param ctx the parse tree */ - void enterAlter_language_stmt(PostgreSqlParser.Alter_language_stmtContext ctx); + void enterOptschemaname(PostgreSqlParser.OptschemanameContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_language_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optschemaname}. * @param ctx the parse tree */ - void exitAlter_language_stmt(PostgreSqlParser.Alter_language_stmtContext ctx); + void exitOptschemaname(PostgreSqlParser.OptschemanameContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_large_object_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optschemaeltlist}. * @param ctx the parse tree */ - void enterAlter_large_object_stmt(PostgreSqlParser.Alter_large_object_stmtContext ctx); + void enterOptschemaeltlist(PostgreSqlParser.OptschemaeltlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_large_object_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optschemaeltlist}. * @param ctx the parse tree */ - void exitAlter_large_object_stmt(PostgreSqlParser.Alter_large_object_stmtContext ctx); + void exitOptschemaeltlist(PostgreSqlParser.OptschemaeltlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_materialize_view_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#schema_stmt}. * @param ctx the parse tree */ - void enterAlter_materialize_view_stmt(PostgreSqlParser.Alter_materialize_view_stmtContext ctx); + void enterSchema_stmt(PostgreSqlParser.Schema_stmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_materialize_view_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#schema_stmt}. * @param ctx the parse tree */ - void exitAlter_materialize_view_stmt(PostgreSqlParser.Alter_materialize_view_stmtContext ctx); + void exitSchema_stmt(PostgreSqlParser.Schema_stmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_operator_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#variablesetstmt}. * @param ctx the parse tree */ - void enterAlter_operator_stmt(PostgreSqlParser.Alter_operator_stmtContext ctx); + void enterVariablesetstmt(PostgreSqlParser.VariablesetstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_operator_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#variablesetstmt}. * @param ctx the parse tree */ - void exitAlter_operator_stmt(PostgreSqlParser.Alter_operator_stmtContext ctx); + void exitVariablesetstmt(PostgreSqlParser.VariablesetstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_operator_class_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#set_rest}. * @param ctx the parse tree */ - void enterAlter_operator_class_stmt(PostgreSqlParser.Alter_operator_class_stmtContext ctx); + void enterSet_rest(PostgreSqlParser.Set_restContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_operator_class_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#set_rest}. * @param ctx the parse tree */ - void exitAlter_operator_class_stmt(PostgreSqlParser.Alter_operator_class_stmtContext ctx); + void exitSet_rest(PostgreSqlParser.Set_restContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_operator_family_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#generic_set}. * @param ctx the parse tree */ - void enterAlter_operator_family_stmt(PostgreSqlParser.Alter_operator_family_stmtContext ctx); + void enterGeneric_set(PostgreSqlParser.Generic_setContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_operator_family_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#generic_set}. * @param ctx the parse tree */ - void exitAlter_operator_family_stmt(PostgreSqlParser.Alter_operator_family_stmtContext ctx); + void exitGeneric_set(PostgreSqlParser.Generic_setContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_policy_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#set_rest_more}. * @param ctx the parse tree */ - void enterAlter_policy_stmt(PostgreSqlParser.Alter_policy_stmtContext ctx); + void enterSet_rest_more(PostgreSqlParser.Set_rest_moreContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_policy_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#set_rest_more}. * @param ctx the parse tree */ - void exitAlter_policy_stmt(PostgreSqlParser.Alter_policy_stmtContext ctx); + void exitSet_rest_more(PostgreSqlParser.Set_rest_moreContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_publication_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#var_name}. * @param ctx the parse tree */ - void enterAlter_publication_stmt(PostgreSqlParser.Alter_publication_stmtContext ctx); + void enterVar_name(PostgreSqlParser.Var_nameContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_publication_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#var_name}. * @param ctx the parse tree */ - void exitAlter_publication_stmt(PostgreSqlParser.Alter_publication_stmtContext ctx); + void exitVar_name(PostgreSqlParser.Var_nameContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_role_options}. + * Enter a parse tree produced by {@link PostgreSqlParser#var_list}. * @param ctx the parse tree */ - void enterAlter_role_options(PostgreSqlParser.Alter_role_optionsContext ctx); + void enterVar_list(PostgreSqlParser.Var_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_role_options}. + * Exit a parse tree produced by {@link PostgreSqlParser#var_list}. * @param ctx the parse tree */ - void exitAlter_role_options(PostgreSqlParser.Alter_role_optionsContext ctx); + void exitVar_list(PostgreSqlParser.Var_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_role_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#var_value}. * @param ctx the parse tree */ - void enterAlter_role_stmt(PostgreSqlParser.Alter_role_stmtContext ctx); + void enterVar_value(PostgreSqlParser.Var_valueContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_role_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#var_value}. * @param ctx the parse tree */ - void exitAlter_role_stmt(PostgreSqlParser.Alter_role_stmtContext ctx); + void exitVar_value(PostgreSqlParser.Var_valueContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_rule_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#iso_level}. * @param ctx the parse tree */ - void enterAlter_rule_stmt(PostgreSqlParser.Alter_rule_stmtContext ctx); + void enterIso_level(PostgreSqlParser.Iso_levelContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_rule_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#iso_level}. * @param ctx the parse tree */ - void exitAlter_rule_stmt(PostgreSqlParser.Alter_rule_stmtContext ctx); + void exitIso_level(PostgreSqlParser.Iso_levelContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_schema_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_boolean_or_string}. * @param ctx the parse tree */ - void enterAlter_schema_stmt(PostgreSqlParser.Alter_schema_stmtContext ctx); + void enterOpt_boolean_or_string(PostgreSqlParser.Opt_boolean_or_stringContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_schema_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_boolean_or_string}. * @param ctx the parse tree */ - void exitAlter_schema_stmt(PostgreSqlParser.Alter_schema_stmtContext ctx); + void exitOpt_boolean_or_string(PostgreSqlParser.Opt_boolean_or_stringContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_sequence_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#zone_value}. * @param ctx the parse tree */ - void enterAlter_sequence_stmt(PostgreSqlParser.Alter_sequence_stmtContext ctx); + void enterZone_value(PostgreSqlParser.Zone_valueContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_sequence_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#zone_value}. * @param ctx the parse tree */ - void exitAlter_sequence_stmt(PostgreSqlParser.Alter_sequence_stmtContext ctx); + void exitZone_value(PostgreSqlParser.Zone_valueContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_server_options_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_encoding}. * @param ctx the parse tree */ - void enterAlter_server_options_list(PostgreSqlParser.Alter_server_options_listContext ctx); + void enterOpt_encoding(PostgreSqlParser.Opt_encodingContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_server_options_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_encoding}. * @param ctx the parse tree */ - void exitAlter_server_options_list(PostgreSqlParser.Alter_server_options_listContext ctx); + void exitOpt_encoding(PostgreSqlParser.Opt_encodingContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_server_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#nonreservedword_or_sconst}. * @param ctx the parse tree */ - void enterAlter_server_stmt(PostgreSqlParser.Alter_server_stmtContext ctx); + void enterNonreservedword_or_sconst(PostgreSqlParser.Nonreservedword_or_sconstContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_server_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#nonreservedword_or_sconst}. * @param ctx the parse tree */ - void exitAlter_server_stmt(PostgreSqlParser.Alter_server_stmtContext ctx); + void exitNonreservedword_or_sconst(PostgreSqlParser.Nonreservedword_or_sconstContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_statistics_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#variableresetstmt}. * @param ctx the parse tree */ - void enterAlter_statistics_stmt(PostgreSqlParser.Alter_statistics_stmtContext ctx); + void enterVariableresetstmt(PostgreSqlParser.VariableresetstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_statistics_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#variableresetstmt}. * @param ctx the parse tree */ - void exitAlter_statistics_stmt(PostgreSqlParser.Alter_statistics_stmtContext ctx); + void exitVariableresetstmt(PostgreSqlParser.VariableresetstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_subscription_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#reset_rest}. * @param ctx the parse tree */ - void enterAlter_subscription_stmt(PostgreSqlParser.Alter_subscription_stmtContext ctx); + void enterReset_rest(PostgreSqlParser.Reset_restContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_subscription_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#reset_rest}. * @param ctx the parse tree */ - void exitAlter_subscription_stmt(PostgreSqlParser.Alter_subscription_stmtContext ctx); + void exitReset_rest(PostgreSqlParser.Reset_restContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_system_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#generic_reset}. * @param ctx the parse tree */ - void enterAlter_system_stmt(PostgreSqlParser.Alter_system_stmtContext ctx); + void enterGeneric_reset(PostgreSqlParser.Generic_resetContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_system_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#generic_reset}. * @param ctx the parse tree */ - void exitAlter_system_stmt(PostgreSqlParser.Alter_system_stmtContext ctx); + void exitGeneric_reset(PostgreSqlParser.Generic_resetContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_table_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#setresetclause}. * @param ctx the parse tree */ - void enterAlter_table_stmt(PostgreSqlParser.Alter_table_stmtContext ctx); + void enterSetresetclause(PostgreSqlParser.SetresetclauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_table_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#setresetclause}. * @param ctx the parse tree */ - void exitAlter_table_stmt(PostgreSqlParser.Alter_table_stmtContext ctx); + void exitSetresetclause(PostgreSqlParser.SetresetclauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_tablespace_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#functionsetresetclause}. * @param ctx the parse tree */ - void enterAlter_tablespace_stmt(PostgreSqlParser.Alter_tablespace_stmtContext ctx); + void enterFunctionsetresetclause(PostgreSqlParser.FunctionsetresetclauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_tablespace_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#functionsetresetclause}. * @param ctx the parse tree */ - void exitAlter_tablespace_stmt(PostgreSqlParser.Alter_tablespace_stmtContext ctx); + void exitFunctionsetresetclause(PostgreSqlParser.FunctionsetresetclauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_text_search_config_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#variableshowstmt}. * @param ctx the parse tree */ - void enterAlter_text_search_config_stmt(PostgreSqlParser.Alter_text_search_config_stmtContext ctx); + void enterVariableshowstmt(PostgreSqlParser.VariableshowstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_text_search_config_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#variableshowstmt}. * @param ctx the parse tree */ - void exitAlter_text_search_config_stmt(PostgreSqlParser.Alter_text_search_config_stmtContext ctx); + void exitVariableshowstmt(PostgreSqlParser.VariableshowstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_text_search_dict_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#constraintssetstmt}. * @param ctx the parse tree */ - void enterAlter_text_search_dict_stmt(PostgreSqlParser.Alter_text_search_dict_stmtContext ctx); + void enterConstraintssetstmt(PostgreSqlParser.ConstraintssetstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_text_search_dict_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#constraintssetstmt}. * @param ctx the parse tree */ - void exitAlter_text_search_dict_stmt(PostgreSqlParser.Alter_text_search_dict_stmtContext ctx); + void exitConstraintssetstmt(PostgreSqlParser.ConstraintssetstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_text_search_parser_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#constraints_set_list}. * @param ctx the parse tree */ - void enterAlter_text_search_parser_stmt(PostgreSqlParser.Alter_text_search_parser_stmtContext ctx); + void enterConstraints_set_list(PostgreSqlParser.Constraints_set_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_text_search_parser_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#constraints_set_list}. * @param ctx the parse tree */ - void exitAlter_text_search_parser_stmt(PostgreSqlParser.Alter_text_search_parser_stmtContext ctx); + void exitConstraints_set_list(PostgreSqlParser.Constraints_set_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_text_search_template_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#constraints_set_mode}. * @param ctx the parse tree */ - void enterAlter_text_search_template_stmt(PostgreSqlParser.Alter_text_search_template_stmtContext ctx); + void enterConstraints_set_mode(PostgreSqlParser.Constraints_set_modeContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_text_search_template_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#constraints_set_mode}. * @param ctx the parse tree */ - void exitAlter_text_search_template_stmt(PostgreSqlParser.Alter_text_search_template_stmtContext ctx); + void exitConstraints_set_mode(PostgreSqlParser.Constraints_set_modeContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_trigger_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#checkpointstmt}. * @param ctx the parse tree */ - void enterAlter_trigger_stmt(PostgreSqlParser.Alter_trigger_stmtContext ctx); + void enterCheckpointstmt(PostgreSqlParser.CheckpointstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_trigger_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#checkpointstmt}. * @param ctx the parse tree */ - void exitAlter_trigger_stmt(PostgreSqlParser.Alter_trigger_stmtContext ctx); + void exitCheckpointstmt(PostgreSqlParser.CheckpointstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_type_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#discardstmt}. * @param ctx the parse tree */ - void enterAlter_type_stmt(PostgreSqlParser.Alter_type_stmtContext ctx); + void enterDiscardstmt(PostgreSqlParser.DiscardstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_type_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#discardstmt}. * @param ctx the parse tree */ - void exitAlter_type_stmt(PostgreSqlParser.Alter_type_stmtContext ctx); + void exitDiscardstmt(PostgreSqlParser.DiscardstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_user_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#altertablestmt}. * @param ctx the parse tree */ - void enterAlter_user_stmt(PostgreSqlParser.Alter_user_stmtContext ctx); + void enterAltertablestmt(PostgreSqlParser.AltertablestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_user_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#altertablestmt}. * @param ctx the parse tree */ - void exitAlter_user_stmt(PostgreSqlParser.Alter_user_stmtContext ctx); + void exitAltertablestmt(PostgreSqlParser.AltertablestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_user_mapping_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_table_cmds}. * @param ctx the parse tree */ - void enterAlter_user_mapping_stmt(PostgreSqlParser.Alter_user_mapping_stmtContext ctx); + void enterAlter_table_cmds(PostgreSqlParser.Alter_table_cmdsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_user_mapping_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_table_cmds}. * @param ctx the parse tree */ - void exitAlter_user_mapping_stmt(PostgreSqlParser.Alter_user_mapping_stmtContext ctx); + void exitAlter_table_cmds(PostgreSqlParser.Alter_table_cmdsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alter_view_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#partition_cmd}. * @param ctx the parse tree */ - void enterAlter_view_stmt(PostgreSqlParser.Alter_view_stmtContext ctx); + void enterPartition_cmd(PostgreSqlParser.Partition_cmdContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alter_view_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#partition_cmd}. * @param ctx the parse tree */ - void exitAlter_view_stmt(PostgreSqlParser.Alter_view_stmtContext ctx); + void exitPartition_cmd(PostgreSqlParser.Partition_cmdContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#analyze_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#index_partition_cmd}. * @param ctx the parse tree */ - void enterAnalyze_stmt(PostgreSqlParser.Analyze_stmtContext ctx); + void enterIndex_partition_cmd(PostgreSqlParser.Index_partition_cmdContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#analyze_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#index_partition_cmd}. * @param ctx the parse tree */ - void exitAnalyze_stmt(PostgreSqlParser.Analyze_stmtContext ctx); + void exitIndex_partition_cmd(PostgreSqlParser.Index_partition_cmdContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#close_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_table_cmd}. * @param ctx the parse tree */ - void enterClose_stmt(PostgreSqlParser.Close_stmtContext ctx); + void enterAlter_table_cmd(PostgreSqlParser.Alter_table_cmdContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#close_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_table_cmd}. * @param ctx the parse tree */ - void exitClose_stmt(PostgreSqlParser.Close_stmtContext ctx); + void exitAlter_table_cmd(PostgreSqlParser.Alter_table_cmdContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#cluster_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_column_default}. * @param ctx the parse tree */ - void enterCluster_stmt(PostgreSqlParser.Cluster_stmtContext ctx); + void enterAlter_column_default(PostgreSqlParser.Alter_column_defaultContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#cluster_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_column_default}. * @param ctx the parse tree */ - void exitCluster_stmt(PostgreSqlParser.Cluster_stmtContext ctx); + void exitAlter_column_default(PostgreSqlParser.Alter_column_defaultContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#comment_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_drop_behavior}. * @param ctx the parse tree */ - void enterComment_stmt(PostgreSqlParser.Comment_stmtContext ctx); + void enterOpt_drop_behavior(PostgreSqlParser.Opt_drop_behaviorContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#comment_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_drop_behavior}. * @param ctx the parse tree */ - void exitComment_stmt(PostgreSqlParser.Comment_stmtContext ctx); + void exitOpt_drop_behavior(PostgreSqlParser.Opt_drop_behaviorContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#commit_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_collate_clause}. * @param ctx the parse tree */ - void enterCommit_stmt(PostgreSqlParser.Commit_stmtContext ctx); + void enterOpt_collate_clause(PostgreSqlParser.Opt_collate_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#commit_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_collate_clause}. * @param ctx the parse tree */ - void exitCommit_stmt(PostgreSqlParser.Commit_stmtContext ctx); + void exitOpt_collate_clause(PostgreSqlParser.Opt_collate_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#commit_prepared_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_using}. * @param ctx the parse tree */ - void enterCommit_prepared_stmt(PostgreSqlParser.Commit_prepared_stmtContext ctx); + void enterAlter_using(PostgreSqlParser.Alter_usingContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#commit_prepared_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_using}. * @param ctx the parse tree */ - void exitCommit_prepared_stmt(PostgreSqlParser.Commit_prepared_stmtContext ctx); + void exitAlter_using(PostgreSqlParser.Alter_usingContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#copy_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#replica_identity}. * @param ctx the parse tree */ - void enterCopy_stmt(PostgreSqlParser.Copy_stmtContext ctx); + void enterReplica_identity(PostgreSqlParser.Replica_identityContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#copy_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#replica_identity}. * @param ctx the parse tree */ - void exitCopy_stmt(PostgreSqlParser.Copy_stmtContext ctx); + void exitReplica_identity(PostgreSqlParser.Replica_identityContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#reloptions}. * @param ctx the parse tree */ - void enterCreate_stmt(PostgreSqlParser.Create_stmtContext ctx); + void enterReloptions(PostgreSqlParser.ReloptionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#reloptions}. * @param ctx the parse tree */ - void exitCreate_stmt(PostgreSqlParser.Create_stmtContext ctx); + void exitReloptions(PostgreSqlParser.ReloptionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_access_method_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_reloptions}. * @param ctx the parse tree */ - void enterCreate_access_method_stmt(PostgreSqlParser.Create_access_method_stmtContext ctx); + void enterOpt_reloptions(PostgreSqlParser.Opt_reloptionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_access_method_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_reloptions}. * @param ctx the parse tree */ - void exitCreate_access_method_stmt(PostgreSqlParser.Create_access_method_stmtContext ctx); + void exitOpt_reloptions(PostgreSqlParser.Opt_reloptionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_aggregate_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#reloption_list}. * @param ctx the parse tree */ - void enterCreate_aggregate_stmt(PostgreSqlParser.Create_aggregate_stmtContext ctx); + void enterReloption_list(PostgreSqlParser.Reloption_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_aggregate_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#reloption_list}. * @param ctx the parse tree */ - void exitCreate_aggregate_stmt(PostgreSqlParser.Create_aggregate_stmtContext ctx); + void exitReloption_list(PostgreSqlParser.Reloption_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_cast_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#reloption_elem}. * @param ctx the parse tree */ - void enterCreate_cast_stmt(PostgreSqlParser.Create_cast_stmtContext ctx); + void enterReloption_elem(PostgreSqlParser.Reloption_elemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_cast_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#reloption_elem}. * @param ctx the parse tree */ - void exitCreate_cast_stmt(PostgreSqlParser.Create_cast_stmtContext ctx); + void exitReloption_elem(PostgreSqlParser.Reloption_elemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_collation_opt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_identity_column_option_list}. * @param ctx the parse tree */ - void enterCreate_collation_opt(PostgreSqlParser.Create_collation_optContext ctx); + void enterAlter_identity_column_option_list(PostgreSqlParser.Alter_identity_column_option_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_collation_opt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_identity_column_option_list}. * @param ctx the parse tree */ - void exitCreate_collation_opt(PostgreSqlParser.Create_collation_optContext ctx); + void exitAlter_identity_column_option_list(PostgreSqlParser.Alter_identity_column_option_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_collation_opt_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_identity_column_option}. * @param ctx the parse tree */ - void enterCreate_collation_opt_list(PostgreSqlParser.Create_collation_opt_listContext ctx); + void enterAlter_identity_column_option(PostgreSqlParser.Alter_identity_column_optionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_collation_opt_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_identity_column_option}. * @param ctx the parse tree */ - void exitCreate_collation_opt_list(PostgreSqlParser.Create_collation_opt_listContext ctx); + void exitAlter_identity_column_option(PostgreSqlParser.Alter_identity_column_optionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_collation_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#partitionboundspec}. * @param ctx the parse tree */ - void enterCreate_collation_stmt(PostgreSqlParser.Create_collation_stmtContext ctx); + void enterPartitionboundspec(PostgreSqlParser.PartitionboundspecContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_collation_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#partitionboundspec}. * @param ctx the parse tree */ - void exitCreate_collation_stmt(PostgreSqlParser.Create_collation_stmtContext ctx); + void exitPartitionboundspec(PostgreSqlParser.PartitionboundspecContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_conversion_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#hash_partbound_elem}. * @param ctx the parse tree */ - void enterCreate_conversion_stmt(PostgreSqlParser.Create_conversion_stmtContext ctx); + void enterHash_partbound_elem(PostgreSqlParser.Hash_partbound_elemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_conversion_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#hash_partbound_elem}. * @param ctx the parse tree */ - void exitCreate_conversion_stmt(PostgreSqlParser.Create_conversion_stmtContext ctx); + void exitHash_partbound_elem(PostgreSqlParser.Hash_partbound_elemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_database_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#hash_partbound}. * @param ctx the parse tree */ - void enterCreate_database_stmt(PostgreSqlParser.Create_database_stmtContext ctx); + void enterHash_partbound(PostgreSqlParser.Hash_partboundContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_database_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#hash_partbound}. * @param ctx the parse tree */ - void exitCreate_database_stmt(PostgreSqlParser.Create_database_stmtContext ctx); + void exitHash_partbound(PostgreSqlParser.Hash_partboundContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#domain_constraint}. + * Enter a parse tree produced by {@link PostgreSqlParser#altercompositetypestmt}. * @param ctx the parse tree */ - void enterDomain_constraint(PostgreSqlParser.Domain_constraintContext ctx); + void enterAltercompositetypestmt(PostgreSqlParser.AltercompositetypestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#domain_constraint}. + * Exit a parse tree produced by {@link PostgreSqlParser#altercompositetypestmt}. * @param ctx the parse tree */ - void exitDomain_constraint(PostgreSqlParser.Domain_constraintContext ctx); + void exitAltercompositetypestmt(PostgreSqlParser.AltercompositetypestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_domain_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_type_cmds}. * @param ctx the parse tree */ - void enterCreate_domain_stmt(PostgreSqlParser.Create_domain_stmtContext ctx); + void enterAlter_type_cmds(PostgreSqlParser.Alter_type_cmdsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_domain_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_type_cmds}. * @param ctx the parse tree */ - void exitCreate_domain_stmt(PostgreSqlParser.Create_domain_stmtContext ctx); + void exitAlter_type_cmds(PostgreSqlParser.Alter_type_cmdsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_event_trigger_cond}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_type_cmd}. * @param ctx the parse tree */ - void enterCreate_event_trigger_cond(PostgreSqlParser.Create_event_trigger_condContext ctx); + void enterAlter_type_cmd(PostgreSqlParser.Alter_type_cmdContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_event_trigger_cond}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_type_cmd}. * @param ctx the parse tree */ - void exitCreate_event_trigger_cond(PostgreSqlParser.Create_event_trigger_condContext ctx); + void exitAlter_type_cmd(PostgreSqlParser.Alter_type_cmdContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_event_trigger_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#closeportalstmt}. * @param ctx the parse tree */ - void enterCreate_event_trigger_stmt(PostgreSqlParser.Create_event_trigger_stmtContext ctx); + void enterCloseportalstmt(PostgreSqlParser.CloseportalstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_event_trigger_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#closeportalstmt}. * @param ctx the parse tree */ - void exitCreate_event_trigger_stmt(PostgreSqlParser.Create_event_trigger_stmtContext ctx); + void exitCloseportalstmt(PostgreSqlParser.CloseportalstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_foreign_data_options}. + * Enter a parse tree produced by {@link PostgreSqlParser#copystmt}. * @param ctx the parse tree */ - void enterCreate_foreign_data_options(PostgreSqlParser.Create_foreign_data_optionsContext ctx); + void enterCopystmt(PostgreSqlParser.CopystmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_foreign_data_options}. + * Exit a parse tree produced by {@link PostgreSqlParser#copystmt}. * @param ctx the parse tree */ - void exitCreate_foreign_data_options(PostgreSqlParser.Create_foreign_data_optionsContext ctx); + void exitCopystmt(PostgreSqlParser.CopystmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_foreign_data_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_from}. * @param ctx the parse tree */ - void enterCreate_foreign_data_stmt(PostgreSqlParser.Create_foreign_data_stmtContext ctx); + void enterCopy_from(PostgreSqlParser.Copy_fromContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_foreign_data_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_from}. * @param ctx the parse tree */ - void exitCreate_foreign_data_stmt(PostgreSqlParser.Create_foreign_data_stmtContext ctx); + void exitCopy_from(PostgreSqlParser.Copy_fromContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_foreign_table_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_program}. * @param ctx the parse tree */ - void enterCreate_foreign_table_stmt(PostgreSqlParser.Create_foreign_table_stmtContext ctx); + void enterOpt_program(PostgreSqlParser.Opt_programContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_foreign_table_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_program}. * @param ctx the parse tree */ - void exitCreate_foreign_table_stmt(PostgreSqlParser.Create_foreign_table_stmtContext ctx); + void exitOpt_program(PostgreSqlParser.Opt_programContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_function_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_file_name}. * @param ctx the parse tree */ - void enterCreate_function_stmt(PostgreSqlParser.Create_function_stmtContext ctx); + void enterCopy_file_name(PostgreSqlParser.Copy_file_nameContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_function_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_file_name}. * @param ctx the parse tree */ - void exitCreate_function_stmt(PostgreSqlParser.Create_function_stmtContext ctx); + void exitCopy_file_name(PostgreSqlParser.Copy_file_nameContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_group_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_options}. * @param ctx the parse tree */ - void enterCreate_group_stmt(PostgreSqlParser.Create_group_stmtContext ctx); + void enterCopy_options(PostgreSqlParser.Copy_optionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_group_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_options}. * @param ctx the parse tree */ - void exitCreate_group_stmt(PostgreSqlParser.Create_group_stmtContext ctx); + void exitCopy_options(PostgreSqlParser.Copy_optionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_index_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_opt_list}. * @param ctx the parse tree */ - void enterCreate_index_stmt(PostgreSqlParser.Create_index_stmtContext ctx); + void enterCopy_opt_list(PostgreSqlParser.Copy_opt_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_index_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_opt_list}. * @param ctx the parse tree */ - void exitCreate_index_stmt(PostgreSqlParser.Create_index_stmtContext ctx); + void exitCopy_opt_list(PostgreSqlParser.Copy_opt_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_language_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_opt_item}. * @param ctx the parse tree */ - void enterCreate_language_stmt(PostgreSqlParser.Create_language_stmtContext ctx); + void enterCopy_opt_item(PostgreSqlParser.Copy_opt_itemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_language_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_opt_item}. * @param ctx the parse tree */ - void exitCreate_language_stmt(PostgreSqlParser.Create_language_stmtContext ctx); + void exitCopy_opt_item(PostgreSqlParser.Copy_opt_itemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_materialized_view_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_binary}. * @param ctx the parse tree */ - void enterCreate_materialized_view_stmt(PostgreSqlParser.Create_materialized_view_stmtContext ctx); + void enterOpt_binary(PostgreSqlParser.Opt_binaryContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_materialized_view_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_binary}. * @param ctx the parse tree */ - void exitCreate_materialized_view_stmt(PostgreSqlParser.Create_materialized_view_stmtContext ctx); + void exitOpt_binary(PostgreSqlParser.Opt_binaryContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_operator_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_delimiter}. * @param ctx the parse tree */ - void enterCreate_operator_stmt(PostgreSqlParser.Create_operator_stmtContext ctx); + void enterCopy_delimiter(PostgreSqlParser.Copy_delimiterContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_operator_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_delimiter}. * @param ctx the parse tree */ - void exitCreate_operator_stmt(PostgreSqlParser.Create_operator_stmtContext ctx); + void exitCopy_delimiter(PostgreSqlParser.Copy_delimiterContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_operator_class_opt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_using}. * @param ctx the parse tree */ - void enterCreate_operator_class_opt(PostgreSqlParser.Create_operator_class_optContext ctx); + void enterOpt_using(PostgreSqlParser.Opt_usingContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_operator_class_opt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_using}. * @param ctx the parse tree */ - void exitCreate_operator_class_opt(PostgreSqlParser.Create_operator_class_optContext ctx); + void exitOpt_using(PostgreSqlParser.Opt_usingContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_operator_class_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_list}. * @param ctx the parse tree */ - void enterCreate_operator_class_stmt(PostgreSqlParser.Create_operator_class_stmtContext ctx); + void enterCopy_generic_opt_list(PostgreSqlParser.Copy_generic_opt_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_operator_class_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_list}. * @param ctx the parse tree */ - void exitCreate_operator_class_stmt(PostgreSqlParser.Create_operator_class_stmtContext ctx); + void exitCopy_generic_opt_list(PostgreSqlParser.Copy_generic_opt_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_operator_family_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_elem}. * @param ctx the parse tree */ - void enterCreate_operator_family_stmt(PostgreSqlParser.Create_operator_family_stmtContext ctx); + void enterCopy_generic_opt_elem(PostgreSqlParser.Copy_generic_opt_elemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_operator_family_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_elem}. * @param ctx the parse tree */ - void exitCreate_operator_family_stmt(PostgreSqlParser.Create_operator_family_stmtContext ctx); + void exitCopy_generic_opt_elem(PostgreSqlParser.Copy_generic_opt_elemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_policy_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_arg}. * @param ctx the parse tree */ - void enterCreate_policy_stmt(PostgreSqlParser.Create_policy_stmtContext ctx); + void enterCopy_generic_opt_arg(PostgreSqlParser.Copy_generic_opt_argContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_policy_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_arg}. * @param ctx the parse tree */ - void exitCreate_policy_stmt(PostgreSqlParser.Create_policy_stmtContext ctx); + void exitCopy_generic_opt_arg(PostgreSqlParser.Copy_generic_opt_argContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_role_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_arg_list}. * @param ctx the parse tree */ - void enterCreate_role_stmt(PostgreSqlParser.Create_role_stmtContext ctx); + void enterCopy_generic_opt_arg_list(PostgreSqlParser.Copy_generic_opt_arg_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_role_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_arg_list}. * @param ctx the parse tree */ - void exitCreate_role_stmt(PostgreSqlParser.Create_role_stmtContext ctx); + void exitCopy_generic_opt_arg_list(PostgreSqlParser.Copy_generic_opt_arg_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_rule_event}. + * Enter a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_arg_list_item}. * @param ctx the parse tree */ - void enterCreate_rule_event(PostgreSqlParser.Create_rule_eventContext ctx); + void enterCopy_generic_opt_arg_list_item(PostgreSqlParser.Copy_generic_opt_arg_list_itemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_rule_event}. + * Exit a parse tree produced by {@link PostgreSqlParser#copy_generic_opt_arg_list_item}. * @param ctx the parse tree */ - void exitCreate_rule_event(PostgreSqlParser.Create_rule_eventContext ctx); + void exitCopy_generic_opt_arg_list_item(PostgreSqlParser.Copy_generic_opt_arg_list_itemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_rule_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createstmt}. * @param ctx the parse tree */ - void enterCreate_rule_stmt(PostgreSqlParser.Create_rule_stmtContext ctx); + void enterCreatestmt(PostgreSqlParser.CreatestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_rule_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createstmt}. * @param ctx the parse tree */ - void exitCreate_rule_stmt(PostgreSqlParser.Create_rule_stmtContext ctx); + void exitCreatestmt(PostgreSqlParser.CreatestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_schema_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opttemp}. * @param ctx the parse tree */ - void enterCreate_schema_stmt(PostgreSqlParser.Create_schema_stmtContext ctx); + void enterOpttemp(PostgreSqlParser.OpttempContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_schema_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opttemp}. * @param ctx the parse tree */ - void exitCreate_schema_stmt(PostgreSqlParser.Create_schema_stmtContext ctx); + void exitOpttemp(PostgreSqlParser.OpttempContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_sequence_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opttableelementlist}. * @param ctx the parse tree */ - void enterCreate_sequence_stmt(PostgreSqlParser.Create_sequence_stmtContext ctx); + void enterOpttableelementlist(PostgreSqlParser.OpttableelementlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_sequence_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opttableelementlist}. * @param ctx the parse tree */ - void exitCreate_sequence_stmt(PostgreSqlParser.Create_sequence_stmtContext ctx); + void exitOpttableelementlist(PostgreSqlParser.OpttableelementlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_server_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opttypedtableelementlist}. * @param ctx the parse tree */ - void enterCreate_server_stmt(PostgreSqlParser.Create_server_stmtContext ctx); + void enterOpttypedtableelementlist(PostgreSqlParser.OpttypedtableelementlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_server_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opttypedtableelementlist}. * @param ctx the parse tree */ - void exitCreate_server_stmt(PostgreSqlParser.Create_server_stmtContext ctx); + void exitOpttypedtableelementlist(PostgreSqlParser.OpttypedtableelementlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_statistics_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#tableelementlist}. * @param ctx the parse tree */ - void enterCreate_statistics_stmt(PostgreSqlParser.Create_statistics_stmtContext ctx); + void enterTableelementlist(PostgreSqlParser.TableelementlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_statistics_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#tableelementlist}. * @param ctx the parse tree */ - void exitCreate_statistics_stmt(PostgreSqlParser.Create_statistics_stmtContext ctx); + void exitTableelementlist(PostgreSqlParser.TableelementlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_subscription_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#typedtableelementlist}. * @param ctx the parse tree */ - void enterCreate_subscription_stmt(PostgreSqlParser.Create_subscription_stmtContext ctx); + void enterTypedtableelementlist(PostgreSqlParser.TypedtableelementlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_subscription_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#typedtableelementlist}. * @param ctx the parse tree */ - void exitCreate_subscription_stmt(PostgreSqlParser.Create_subscription_stmtContext ctx); + void exitTypedtableelementlist(PostgreSqlParser.TypedtableelementlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_table_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#tableelement}. * @param ctx the parse tree */ - void enterCreate_table_stmt(PostgreSqlParser.Create_table_stmtContext ctx); + void enterTableelement(PostgreSqlParser.TableelementContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_table_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#tableelement}. * @param ctx the parse tree */ - void exitCreate_table_stmt(PostgreSqlParser.Create_table_stmtContext ctx); + void exitTableelement(PostgreSqlParser.TableelementContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_table_as_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#typedtableelement}. * @param ctx the parse tree */ - void enterCreate_table_as_stmt(PostgreSqlParser.Create_table_as_stmtContext ctx); + void enterTypedtableelement(PostgreSqlParser.TypedtableelementContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_table_as_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#typedtableelement}. * @param ctx the parse tree */ - void exitCreate_table_as_stmt(PostgreSqlParser.Create_table_as_stmtContext ctx); + void exitTypedtableelement(PostgreSqlParser.TypedtableelementContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_tablespace_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#columnDef}. * @param ctx the parse tree */ - void enterCreate_tablespace_stmt(PostgreSqlParser.Create_tablespace_stmtContext ctx); + void enterColumnDef(PostgreSqlParser.ColumnDefContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_tablespace_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#columnDef}. * @param ctx the parse tree */ - void exitCreate_tablespace_stmt(PostgreSqlParser.Create_tablespace_stmtContext ctx); + void exitColumnDef(PostgreSqlParser.ColumnDefContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_text_search_config_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#columnOptions}. * @param ctx the parse tree */ - void enterCreate_text_search_config_stmt(PostgreSqlParser.Create_text_search_config_stmtContext ctx); + void enterColumnOptions(PostgreSqlParser.ColumnOptionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_text_search_config_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#columnOptions}. * @param ctx the parse tree */ - void exitCreate_text_search_config_stmt(PostgreSqlParser.Create_text_search_config_stmtContext ctx); + void exitColumnOptions(PostgreSqlParser.ColumnOptionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_text_search_dict_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#colquallist}. * @param ctx the parse tree */ - void enterCreate_text_search_dict_stmt(PostgreSqlParser.Create_text_search_dict_stmtContext ctx); + void enterColquallist(PostgreSqlParser.ColquallistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_text_search_dict_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#colquallist}. * @param ctx the parse tree */ - void exitCreate_text_search_dict_stmt(PostgreSqlParser.Create_text_search_dict_stmtContext ctx); + void exitColquallist(PostgreSqlParser.ColquallistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_text_search_parser_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#colconstraint}. * @param ctx the parse tree */ - void enterCreate_text_search_parser_stmt(PostgreSqlParser.Create_text_search_parser_stmtContext ctx); + void enterColconstraint(PostgreSqlParser.ColconstraintContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_text_search_parser_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#colconstraint}. * @param ctx the parse tree */ - void exitCreate_text_search_parser_stmt(PostgreSqlParser.Create_text_search_parser_stmtContext ctx); + void exitColconstraint(PostgreSqlParser.ColconstraintContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_text_search_template_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#colconstraintelem}. * @param ctx the parse tree */ - void enterCreate_text_search_template_stmt(PostgreSqlParser.Create_text_search_template_stmtContext ctx); + void enterColconstraintelem(PostgreSqlParser.ColconstraintelemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_text_search_template_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#colconstraintelem}. * @param ctx the parse tree */ - void exitCreate_text_search_template_stmt(PostgreSqlParser.Create_text_search_template_stmtContext ctx); + void exitColconstraintelem(PostgreSqlParser.ColconstraintelemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_transform_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#generated_when}. * @param ctx the parse tree */ - void enterCreate_transform_stmt(PostgreSqlParser.Create_transform_stmtContext ctx); + void enterGenerated_when(PostgreSqlParser.Generated_whenContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_transform_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#generated_when}. * @param ctx the parse tree */ - void exitCreate_transform_stmt(PostgreSqlParser.Create_transform_stmtContext ctx); + void exitGenerated_when(PostgreSqlParser.Generated_whenContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_trigger_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#constraintattr}. * @param ctx the parse tree */ - void enterCreate_trigger_stmt(PostgreSqlParser.Create_trigger_stmtContext ctx); + void enterConstraintattr(PostgreSqlParser.ConstraintattrContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_trigger_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#constraintattr}. * @param ctx the parse tree */ - void exitCreate_trigger_stmt(PostgreSqlParser.Create_trigger_stmtContext ctx); + void exitConstraintattr(PostgreSqlParser.ConstraintattrContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_type_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#tablelikeclause}. * @param ctx the parse tree */ - void enterCreate_type_stmt(PostgreSqlParser.Create_type_stmtContext ctx); + void enterTablelikeclause(PostgreSqlParser.TablelikeclauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_type_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#tablelikeclause}. * @param ctx the parse tree */ - void exitCreate_type_stmt(PostgreSqlParser.Create_type_stmtContext ctx); + void exitTablelikeclause(PostgreSqlParser.TablelikeclauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_user_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#tablelikeoptionlist}. * @param ctx the parse tree */ - void enterCreate_user_stmt(PostgreSqlParser.Create_user_stmtContext ctx); + void enterTablelikeoptionlist(PostgreSqlParser.TablelikeoptionlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_user_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#tablelikeoptionlist}. * @param ctx the parse tree */ - void exitCreate_user_stmt(PostgreSqlParser.Create_user_stmtContext ctx); + void exitTablelikeoptionlist(PostgreSqlParser.TablelikeoptionlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_user_mapping_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#tablelikeoption}. * @param ctx the parse tree */ - void enterCreate_user_mapping_stmt(PostgreSqlParser.Create_user_mapping_stmtContext ctx); + void enterTablelikeoption(PostgreSqlParser.TablelikeoptionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_user_mapping_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#tablelikeoption}. * @param ctx the parse tree */ - void exitCreate_user_mapping_stmt(PostgreSqlParser.Create_user_mapping_stmtContext ctx); + void exitTablelikeoption(PostgreSqlParser.TablelikeoptionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#create_view_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#tableconstraint}. * @param ctx the parse tree */ - void enterCreate_view_stmt(PostgreSqlParser.Create_view_stmtContext ctx); + void enterTableconstraint(PostgreSqlParser.TableconstraintContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#create_view_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#tableconstraint}. * @param ctx the parse tree */ - void exitCreate_view_stmt(PostgreSqlParser.Create_view_stmtContext ctx); + void exitTableconstraint(PostgreSqlParser.TableconstraintContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#deallocate_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#constraintelem}. * @param ctx the parse tree */ - void enterDeallocate_stmt(PostgreSqlParser.Deallocate_stmtContext ctx); + void enterConstraintelem(PostgreSqlParser.ConstraintelemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#deallocate_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#constraintelem}. * @param ctx the parse tree */ - void exitDeallocate_stmt(PostgreSqlParser.Deallocate_stmtContext ctx); + void exitConstraintelem(PostgreSqlParser.ConstraintelemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#declare_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_no_inherit}. * @param ctx the parse tree */ - void enterDeclare_stmt(PostgreSqlParser.Declare_stmtContext ctx); + void enterOpt_no_inherit(PostgreSqlParser.Opt_no_inheritContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#declare_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_no_inherit}. * @param ctx the parse tree */ - void exitDeclare_stmt(PostgreSqlParser.Declare_stmtContext ctx); + void exitOpt_no_inherit(PostgreSqlParser.Opt_no_inheritContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#delete_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_column_list}. * @param ctx the parse tree */ - void enterDelete_stmt(PostgreSqlParser.Delete_stmtContext ctx); + void enterOpt_column_list(PostgreSqlParser.Opt_column_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#delete_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_column_list}. * @param ctx the parse tree */ - void exitDelete_stmt(PostgreSqlParser.Delete_stmtContext ctx); + void exitOpt_column_list(PostgreSqlParser.Opt_column_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#discard_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#columnlist}. * @param ctx the parse tree */ - void enterDiscard_stmt(PostgreSqlParser.Discard_stmtContext ctx); + void enterColumnlist(PostgreSqlParser.ColumnlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#discard_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#columnlist}. * @param ctx the parse tree */ - void exitDiscard_stmt(PostgreSqlParser.Discard_stmtContext ctx); + void exitColumnlist(PostgreSqlParser.ColumnlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#columnElem}. * @param ctx the parse tree */ - void enterDrop_stmt(PostgreSqlParser.Drop_stmtContext ctx); + void enterColumnElem(PostgreSqlParser.ColumnElemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#columnElem}. * @param ctx the parse tree */ - void exitDrop_stmt(PostgreSqlParser.Drop_stmtContext ctx); + void exitColumnElem(PostgreSqlParser.ColumnElemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_access_method_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_c_include}. * @param ctx the parse tree */ - void enterDrop_access_method_stmt(PostgreSqlParser.Drop_access_method_stmtContext ctx); + void enterOpt_c_include(PostgreSqlParser.Opt_c_includeContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_access_method_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_c_include}. * @param ctx the parse tree */ - void exitDrop_access_method_stmt(PostgreSqlParser.Drop_access_method_stmtContext ctx); + void exitOpt_c_include(PostgreSqlParser.Opt_c_includeContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_aggregate_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#key_match}. * @param ctx the parse tree */ - void enterDrop_aggregate_stmt(PostgreSqlParser.Drop_aggregate_stmtContext ctx); + void enterKey_match(PostgreSqlParser.Key_matchContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_aggregate_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#key_match}. * @param ctx the parse tree */ - void exitDrop_aggregate_stmt(PostgreSqlParser.Drop_aggregate_stmtContext ctx); + void exitKey_match(PostgreSqlParser.Key_matchContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_cast_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#exclusionconstraintlist}. * @param ctx the parse tree */ - void enterDrop_cast_stmt(PostgreSqlParser.Drop_cast_stmtContext ctx); + void enterExclusionconstraintlist(PostgreSqlParser.ExclusionconstraintlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_cast_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#exclusionconstraintlist}. * @param ctx the parse tree */ - void exitDrop_cast_stmt(PostgreSqlParser.Drop_cast_stmtContext ctx); + void exitExclusionconstraintlist(PostgreSqlParser.ExclusionconstraintlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_collation_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#exclusionconstraintelem}. * @param ctx the parse tree */ - void enterDrop_collation_stmt(PostgreSqlParser.Drop_collation_stmtContext ctx); + void enterExclusionconstraintelem(PostgreSqlParser.ExclusionconstraintelemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_collation_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#exclusionconstraintelem}. * @param ctx the parse tree */ - void exitDrop_collation_stmt(PostgreSqlParser.Drop_collation_stmtContext ctx); + void exitExclusionconstraintelem(PostgreSqlParser.ExclusionconstraintelemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_conversion_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#exclusionwhereclause}. * @param ctx the parse tree */ - void enterDrop_conversion_stmt(PostgreSqlParser.Drop_conversion_stmtContext ctx); + void enterExclusionwhereclause(PostgreSqlParser.ExclusionwhereclauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_conversion_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#exclusionwhereclause}. * @param ctx the parse tree */ - void exitDrop_conversion_stmt(PostgreSqlParser.Drop_conversion_stmtContext ctx); + void exitExclusionwhereclause(PostgreSqlParser.ExclusionwhereclauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_database_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#key_actions}. * @param ctx the parse tree */ - void enterDrop_database_stmt(PostgreSqlParser.Drop_database_stmtContext ctx); + void enterKey_actions(PostgreSqlParser.Key_actionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_database_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#key_actions}. * @param ctx the parse tree */ - void exitDrop_database_stmt(PostgreSqlParser.Drop_database_stmtContext ctx); + void exitKey_actions(PostgreSqlParser.Key_actionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_domain_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#key_update}. * @param ctx the parse tree */ - void enterDrop_domain_stmt(PostgreSqlParser.Drop_domain_stmtContext ctx); + void enterKey_update(PostgreSqlParser.Key_updateContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_domain_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#key_update}. * @param ctx the parse tree */ - void exitDrop_domain_stmt(PostgreSqlParser.Drop_domain_stmtContext ctx); + void exitKey_update(PostgreSqlParser.Key_updateContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_event_trigger_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#key_delete}. * @param ctx the parse tree */ - void enterDrop_event_trigger_stmt(PostgreSqlParser.Drop_event_trigger_stmtContext ctx); + void enterKey_delete(PostgreSqlParser.Key_deleteContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_event_trigger_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#key_delete}. * @param ctx the parse tree */ - void exitDrop_event_trigger_stmt(PostgreSqlParser.Drop_event_trigger_stmtContext ctx); + void exitKey_delete(PostgreSqlParser.Key_deleteContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_extension_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#key_action}. * @param ctx the parse tree */ - void enterDrop_extension_stmt(PostgreSqlParser.Drop_extension_stmtContext ctx); + void enterKey_action(PostgreSqlParser.Key_actionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_extension_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#key_action}. * @param ctx the parse tree */ - void exitDrop_extension_stmt(PostgreSqlParser.Drop_extension_stmtContext ctx); + void exitKey_action(PostgreSqlParser.Key_actionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_foreign_data_wrapper_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optinherit}. * @param ctx the parse tree */ - void enterDrop_foreign_data_wrapper_stmt(PostgreSqlParser.Drop_foreign_data_wrapper_stmtContext ctx); + void enterOptinherit(PostgreSqlParser.OptinheritContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_foreign_data_wrapper_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optinherit}. * @param ctx the parse tree */ - void exitDrop_foreign_data_wrapper_stmt(PostgreSqlParser.Drop_foreign_data_wrapper_stmtContext ctx); + void exitOptinherit(PostgreSqlParser.OptinheritContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_foreign_table_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optpartitionspec}. * @param ctx the parse tree */ - void enterDrop_foreign_table_stmt(PostgreSqlParser.Drop_foreign_table_stmtContext ctx); + void enterOptpartitionspec(PostgreSqlParser.OptpartitionspecContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_foreign_table_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optpartitionspec}. * @param ctx the parse tree */ - void exitDrop_foreign_table_stmt(PostgreSqlParser.Drop_foreign_table_stmtContext ctx); + void exitOptpartitionspec(PostgreSqlParser.OptpartitionspecContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_function_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#partitionspec}. * @param ctx the parse tree */ - void enterDrop_function_stmt(PostgreSqlParser.Drop_function_stmtContext ctx); + void enterPartitionspec(PostgreSqlParser.PartitionspecContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_function_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#partitionspec}. * @param ctx the parse tree */ - void exitDrop_function_stmt(PostgreSqlParser.Drop_function_stmtContext ctx); + void exitPartitionspec(PostgreSqlParser.PartitionspecContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_group_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#part_params}. * @param ctx the parse tree */ - void enterDrop_group_stmt(PostgreSqlParser.Drop_group_stmtContext ctx); + void enterPart_params(PostgreSqlParser.Part_paramsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_group_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#part_params}. * @param ctx the parse tree */ - void exitDrop_group_stmt(PostgreSqlParser.Drop_group_stmtContext ctx); + void exitPart_params(PostgreSqlParser.Part_paramsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_index_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#part_elem}. * @param ctx the parse tree */ - void enterDrop_index_stmt(PostgreSqlParser.Drop_index_stmtContext ctx); + void enterPart_elem(PostgreSqlParser.Part_elemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_index_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#part_elem}. * @param ctx the parse tree */ - void exitDrop_index_stmt(PostgreSqlParser.Drop_index_stmtContext ctx); + void exitPart_elem(PostgreSqlParser.Part_elemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_language_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#table_access_method_clause}. * @param ctx the parse tree */ - void enterDrop_language_stmt(PostgreSqlParser.Drop_language_stmtContext ctx); + void enterTable_access_method_clause(PostgreSqlParser.Table_access_method_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_language_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#table_access_method_clause}. * @param ctx the parse tree */ - void exitDrop_language_stmt(PostgreSqlParser.Drop_language_stmtContext ctx); + void exitTable_access_method_clause(PostgreSqlParser.Table_access_method_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_materialized_view_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optwith}. * @param ctx the parse tree */ - void enterDrop_materialized_view_stmt(PostgreSqlParser.Drop_materialized_view_stmtContext ctx); + void enterOptwith(PostgreSqlParser.OptwithContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_materialized_view_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optwith}. * @param ctx the parse tree */ - void exitDrop_materialized_view_stmt(PostgreSqlParser.Drop_materialized_view_stmtContext ctx); + void exitOptwith(PostgreSqlParser.OptwithContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_operator_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#oncommitoption}. * @param ctx the parse tree */ - void enterDrop_operator_stmt(PostgreSqlParser.Drop_operator_stmtContext ctx); + void enterOncommitoption(PostgreSqlParser.OncommitoptionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_operator_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#oncommitoption}. * @param ctx the parse tree */ - void exitDrop_operator_stmt(PostgreSqlParser.Drop_operator_stmtContext ctx); + void exitOncommitoption(PostgreSqlParser.OncommitoptionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_operator_class_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opttablespace}. * @param ctx the parse tree */ - void enterDrop_operator_class_stmt(PostgreSqlParser.Drop_operator_class_stmtContext ctx); + void enterOpttablespace(PostgreSqlParser.OpttablespaceContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_operator_class_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opttablespace}. * @param ctx the parse tree */ - void exitDrop_operator_class_stmt(PostgreSqlParser.Drop_operator_class_stmtContext ctx); + void exitOpttablespace(PostgreSqlParser.OpttablespaceContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_operator_family_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optconstablespace}. * @param ctx the parse tree */ - void enterDrop_operator_family_stmt(PostgreSqlParser.Drop_operator_family_stmtContext ctx); + void enterOptconstablespace(PostgreSqlParser.OptconstablespaceContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_operator_family_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optconstablespace}. * @param ctx the parse tree */ - void exitDrop_operator_family_stmt(PostgreSqlParser.Drop_operator_family_stmtContext ctx); + void exitOptconstablespace(PostgreSqlParser.OptconstablespaceContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_owned_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#existingindex}. * @param ctx the parse tree */ - void enterDrop_owned_stmt(PostgreSqlParser.Drop_owned_stmtContext ctx); + void enterExistingindex(PostgreSqlParser.ExistingindexContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_owned_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#existingindex}. * @param ctx the parse tree */ - void exitDrop_owned_stmt(PostgreSqlParser.Drop_owned_stmtContext ctx); + void exitExistingindex(PostgreSqlParser.ExistingindexContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_policy_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createstatsstmt}. * @param ctx the parse tree */ - void enterDrop_policy_stmt(PostgreSqlParser.Drop_policy_stmtContext ctx); + void enterCreatestatsstmt(PostgreSqlParser.CreatestatsstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_policy_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createstatsstmt}. * @param ctx the parse tree */ - void exitDrop_policy_stmt(PostgreSqlParser.Drop_policy_stmtContext ctx); + void exitCreatestatsstmt(PostgreSqlParser.CreatestatsstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_publication_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterstatsstmt}. * @param ctx the parse tree */ - void enterDrop_publication_stmt(PostgreSqlParser.Drop_publication_stmtContext ctx); + void enterAlterstatsstmt(PostgreSqlParser.AlterstatsstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_publication_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterstatsstmt}. * @param ctx the parse tree */ - void exitDrop_publication_stmt(PostgreSqlParser.Drop_publication_stmtContext ctx); + void exitAlterstatsstmt(PostgreSqlParser.AlterstatsstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_role_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createasstmt}. * @param ctx the parse tree */ - void enterDrop_role_stmt(PostgreSqlParser.Drop_role_stmtContext ctx); + void enterCreateasstmt(PostgreSqlParser.CreateasstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_role_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createasstmt}. * @param ctx the parse tree */ - void exitDrop_role_stmt(PostgreSqlParser.Drop_role_stmtContext ctx); + void exitCreateasstmt(PostgreSqlParser.CreateasstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_rule_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#create_as_target}. * @param ctx the parse tree */ - void enterDrop_rule_stmt(PostgreSqlParser.Drop_rule_stmtContext ctx); + void enterCreate_as_target(PostgreSqlParser.Create_as_targetContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_rule_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#create_as_target}. * @param ctx the parse tree */ - void exitDrop_rule_stmt(PostgreSqlParser.Drop_rule_stmtContext ctx); + void exitCreate_as_target(PostgreSqlParser.Create_as_targetContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_schema_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_with_data}. * @param ctx the parse tree */ - void enterDrop_schema_stmt(PostgreSqlParser.Drop_schema_stmtContext ctx); + void enterOpt_with_data(PostgreSqlParser.Opt_with_dataContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_schema_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_with_data}. * @param ctx the parse tree */ - void exitDrop_schema_stmt(PostgreSqlParser.Drop_schema_stmtContext ctx); + void exitOpt_with_data(PostgreSqlParser.Opt_with_dataContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_sequence_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#creatematviewstmt}. * @param ctx the parse tree */ - void enterDrop_sequence_stmt(PostgreSqlParser.Drop_sequence_stmtContext ctx); + void enterCreatematviewstmt(PostgreSqlParser.CreatematviewstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_sequence_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#creatematviewstmt}. * @param ctx the parse tree */ - void exitDrop_sequence_stmt(PostgreSqlParser.Drop_sequence_stmtContext ctx); + void exitCreatematviewstmt(PostgreSqlParser.CreatematviewstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_server_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#create_mv_target}. * @param ctx the parse tree */ - void enterDrop_server_stmt(PostgreSqlParser.Drop_server_stmtContext ctx); + void enterCreate_mv_target(PostgreSqlParser.Create_mv_targetContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_server_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#create_mv_target}. * @param ctx the parse tree */ - void exitDrop_server_stmt(PostgreSqlParser.Drop_server_stmtContext ctx); + void exitCreate_mv_target(PostgreSqlParser.Create_mv_targetContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_statistics_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optnolog}. * @param ctx the parse tree */ - void enterDrop_statistics_stmt(PostgreSqlParser.Drop_statistics_stmtContext ctx); + void enterOptnolog(PostgreSqlParser.OptnologContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_statistics_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optnolog}. * @param ctx the parse tree */ - void exitDrop_statistics_stmt(PostgreSqlParser.Drop_statistics_stmtContext ctx); + void exitOptnolog(PostgreSqlParser.OptnologContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_subscription_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#refreshmatviewstmt}. * @param ctx the parse tree */ - void enterDrop_subscription_stmt(PostgreSqlParser.Drop_subscription_stmtContext ctx); + void enterRefreshmatviewstmt(PostgreSqlParser.RefreshmatviewstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_subscription_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#refreshmatviewstmt}. * @param ctx the parse tree */ - void exitDrop_subscription_stmt(PostgreSqlParser.Drop_subscription_stmtContext ctx); + void exitRefreshmatviewstmt(PostgreSqlParser.RefreshmatviewstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_table_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createseqstmt}. * @param ctx the parse tree */ - void enterDrop_table_stmt(PostgreSqlParser.Drop_table_stmtContext ctx); + void enterCreateseqstmt(PostgreSqlParser.CreateseqstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_table_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createseqstmt}. * @param ctx the parse tree */ - void exitDrop_table_stmt(PostgreSqlParser.Drop_table_stmtContext ctx); + void exitCreateseqstmt(PostgreSqlParser.CreateseqstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_tablespace_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterseqstmt}. * @param ctx the parse tree */ - void enterDrop_tablespace_stmt(PostgreSqlParser.Drop_tablespace_stmtContext ctx); + void enterAlterseqstmt(PostgreSqlParser.AlterseqstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_tablespace_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterseqstmt}. * @param ctx the parse tree */ - void exitDrop_tablespace_stmt(PostgreSqlParser.Drop_tablespace_stmtContext ctx); + void exitAlterseqstmt(PostgreSqlParser.AlterseqstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_text_search_config_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optseqoptlist}. * @param ctx the parse tree */ - void enterDrop_text_search_config_stmt(PostgreSqlParser.Drop_text_search_config_stmtContext ctx); + void enterOptseqoptlist(PostgreSqlParser.OptseqoptlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_text_search_config_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optseqoptlist}. * @param ctx the parse tree */ - void exitDrop_text_search_config_stmt(PostgreSqlParser.Drop_text_search_config_stmtContext ctx); + void exitOptseqoptlist(PostgreSqlParser.OptseqoptlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_text_search_dict_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#optparenthesizedseqoptlist}. * @param ctx the parse tree */ - void enterDrop_text_search_dict_stmt(PostgreSqlParser.Drop_text_search_dict_stmtContext ctx); + void enterOptparenthesizedseqoptlist(PostgreSqlParser.OptparenthesizedseqoptlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_text_search_dict_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#optparenthesizedseqoptlist}. * @param ctx the parse tree */ - void exitDrop_text_search_dict_stmt(PostgreSqlParser.Drop_text_search_dict_stmtContext ctx); + void exitOptparenthesizedseqoptlist(PostgreSqlParser.OptparenthesizedseqoptlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_text_search_parser_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#seqoptlist}. * @param ctx the parse tree */ - void enterDrop_text_search_parser_stmt(PostgreSqlParser.Drop_text_search_parser_stmtContext ctx); + void enterSeqoptlist(PostgreSqlParser.SeqoptlistContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_text_search_parser_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#seqoptlist}. * @param ctx the parse tree */ - void exitDrop_text_search_parser_stmt(PostgreSqlParser.Drop_text_search_parser_stmtContext ctx); + void exitSeqoptlist(PostgreSqlParser.SeqoptlistContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_text_search_template_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#seqoptelem}. * @param ctx the parse tree */ - void enterDrop_text_search_template_stmt(PostgreSqlParser.Drop_text_search_template_stmtContext ctx); + void enterSeqoptelem(PostgreSqlParser.SeqoptelemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_text_search_template_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#seqoptelem}. * @param ctx the parse tree */ - void exitDrop_text_search_template_stmt(PostgreSqlParser.Drop_text_search_template_stmtContext ctx); + void exitSeqoptelem(PostgreSqlParser.SeqoptelemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_transform_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_by}. * @param ctx the parse tree */ - void enterDrop_transform_stmt(PostgreSqlParser.Drop_transform_stmtContext ctx); + void enterOpt_by(PostgreSqlParser.Opt_byContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_transform_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_by}. * @param ctx the parse tree */ - void exitDrop_transform_stmt(PostgreSqlParser.Drop_transform_stmtContext ctx); + void exitOpt_by(PostgreSqlParser.Opt_byContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_trigger_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#numericonly}. * @param ctx the parse tree */ - void enterDrop_trigger_stmt(PostgreSqlParser.Drop_trigger_stmtContext ctx); + void enterNumericonly(PostgreSqlParser.NumericonlyContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_trigger_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#numericonly}. * @param ctx the parse tree */ - void exitDrop_trigger_stmt(PostgreSqlParser.Drop_trigger_stmtContext ctx); + void exitNumericonly(PostgreSqlParser.NumericonlyContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_type_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#numericonly_list}. * @param ctx the parse tree */ - void enterDrop_type_stmt(PostgreSqlParser.Drop_type_stmtContext ctx); + void enterNumericonly_list(PostgreSqlParser.Numericonly_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_type_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#numericonly_list}. * @param ctx the parse tree */ - void exitDrop_type_stmt(PostgreSqlParser.Drop_type_stmtContext ctx); + void exitNumericonly_list(PostgreSqlParser.Numericonly_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_user_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createplangstmt}. * @param ctx the parse tree */ - void enterDrop_user_stmt(PostgreSqlParser.Drop_user_stmtContext ctx); + void enterCreateplangstmt(PostgreSqlParser.CreateplangstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_user_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createplangstmt}. * @param ctx the parse tree */ - void exitDrop_user_stmt(PostgreSqlParser.Drop_user_stmtContext ctx); + void exitCreateplangstmt(PostgreSqlParser.CreateplangstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_user_mapping_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_trusted}. * @param ctx the parse tree */ - void enterDrop_user_mapping_stmt(PostgreSqlParser.Drop_user_mapping_stmtContext ctx); + void enterOpt_trusted(PostgreSqlParser.Opt_trustedContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_user_mapping_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_trusted}. * @param ctx the parse tree */ - void exitDrop_user_mapping_stmt(PostgreSqlParser.Drop_user_mapping_stmtContext ctx); + void exitOpt_trusted(PostgreSqlParser.Opt_trustedContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#drop_view_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#handler_name}. * @param ctx the parse tree */ - void enterDrop_view_stmt(PostgreSqlParser.Drop_view_stmtContext ctx); + void enterHandler_name(PostgreSqlParser.Handler_nameContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#drop_view_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#handler_name}. * @param ctx the parse tree */ - void exitDrop_view_stmt(PostgreSqlParser.Drop_view_stmtContext ctx); + void exitHandler_name(PostgreSqlParser.Handler_nameContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#execute_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_inline_handler}. * @param ctx the parse tree */ - void enterExecute_stmt(PostgreSqlParser.Execute_stmtContext ctx); + void enterOpt_inline_handler(PostgreSqlParser.Opt_inline_handlerContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#execute_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_inline_handler}. * @param ctx the parse tree */ - void exitExecute_stmt(PostgreSqlParser.Execute_stmtContext ctx); + void exitOpt_inline_handler(PostgreSqlParser.Opt_inline_handlerContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#explain_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#validator_clause}. * @param ctx the parse tree */ - void enterExplain_stmt(PostgreSqlParser.Explain_stmtContext ctx); + void enterValidator_clause(PostgreSqlParser.Validator_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#explain_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#validator_clause}. * @param ctx the parse tree */ - void exitExplain_stmt(PostgreSqlParser.Explain_stmtContext ctx); + void exitValidator_clause(PostgreSqlParser.Validator_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#fetch_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_validator}. * @param ctx the parse tree */ - void enterFetch_stmt(PostgreSqlParser.Fetch_stmtContext ctx); + void enterOpt_validator(PostgreSqlParser.Opt_validatorContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#fetch_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_validator}. * @param ctx the parse tree */ - void exitFetch_stmt(PostgreSqlParser.Fetch_stmtContext ctx); + void exitOpt_validator(PostgreSqlParser.Opt_validatorContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#grant_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_procedural}. * @param ctx the parse tree */ - void enterGrant_stmt(PostgreSqlParser.Grant_stmtContext ctx); + void enterOpt_procedural(PostgreSqlParser.Opt_proceduralContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#grant_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_procedural}. * @param ctx the parse tree */ - void exitGrant_stmt(PostgreSqlParser.Grant_stmtContext ctx); + void exitOpt_procedural(PostgreSqlParser.Opt_proceduralContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#import_foreign_schema_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createtablespacestmt}. * @param ctx the parse tree */ - void enterImport_foreign_schema_stmt(PostgreSqlParser.Import_foreign_schema_stmtContext ctx); + void enterCreatetablespacestmt(PostgreSqlParser.CreatetablespacestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#import_foreign_schema_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createtablespacestmt}. * @param ctx the parse tree */ - void exitImport_foreign_schema_stmt(PostgreSqlParser.Import_foreign_schema_stmtContext ctx); + void exitCreatetablespacestmt(PostgreSqlParser.CreatetablespacestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#insert_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opttablespaceowner}. * @param ctx the parse tree */ - void enterInsert_stmt(PostgreSqlParser.Insert_stmtContext ctx); + void enterOpttablespaceowner(PostgreSqlParser.OpttablespaceownerContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#insert_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opttablespaceowner}. * @param ctx the parse tree */ - void exitInsert_stmt(PostgreSqlParser.Insert_stmtContext ctx); + void exitOpttablespaceowner(PostgreSqlParser.OpttablespaceownerContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#listen_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#droptablespacestmt}. * @param ctx the parse tree */ - void enterListen_stmt(PostgreSqlParser.Listen_stmtContext ctx); + void enterDroptablespacestmt(PostgreSqlParser.DroptablespacestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#listen_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#droptablespacestmt}. * @param ctx the parse tree */ - void exitListen_stmt(PostgreSqlParser.Listen_stmtContext ctx); + void exitDroptablespacestmt(PostgreSqlParser.DroptablespacestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#load_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createextensionstmt}. * @param ctx the parse tree */ - void enterLoad_stmt(PostgreSqlParser.Load_stmtContext ctx); + void enterCreateextensionstmt(PostgreSqlParser.CreateextensionstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#load_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createextensionstmt}. * @param ctx the parse tree */ - void exitLoad_stmt(PostgreSqlParser.Load_stmtContext ctx); + void exitCreateextensionstmt(PostgreSqlParser.CreateextensionstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#lock_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#create_extension_opt_list}. * @param ctx the parse tree */ - void enterLock_stmt(PostgreSqlParser.Lock_stmtContext ctx); + void enterCreate_extension_opt_list(PostgreSqlParser.Create_extension_opt_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#lock_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#create_extension_opt_list}. * @param ctx the parse tree */ - void exitLock_stmt(PostgreSqlParser.Lock_stmtContext ctx); + void exitCreate_extension_opt_list(PostgreSqlParser.Create_extension_opt_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#move_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#create_extension_opt_item}. * @param ctx the parse tree */ - void enterMove_stmt(PostgreSqlParser.Move_stmtContext ctx); + void enterCreate_extension_opt_item(PostgreSqlParser.Create_extension_opt_itemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#move_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#create_extension_opt_item}. * @param ctx the parse tree */ - void exitMove_stmt(PostgreSqlParser.Move_stmtContext ctx); + void exitCreate_extension_opt_item(PostgreSqlParser.Create_extension_opt_itemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#notify_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterextensionstmt}. * @param ctx the parse tree */ - void enterNotify_stmt(PostgreSqlParser.Notify_stmtContext ctx); + void enterAlterextensionstmt(PostgreSqlParser.AlterextensionstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#notify_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterextensionstmt}. * @param ctx the parse tree */ - void exitNotify_stmt(PostgreSqlParser.Notify_stmtContext ctx); + void exitAlterextensionstmt(PostgreSqlParser.AlterextensionstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#prepare_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_extension_opt_list}. * @param ctx the parse tree */ - void enterPrepare_stmt(PostgreSqlParser.Prepare_stmtContext ctx); + void enterAlter_extension_opt_list(PostgreSqlParser.Alter_extension_opt_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#prepare_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_extension_opt_list}. * @param ctx the parse tree */ - void exitPrepare_stmt(PostgreSqlParser.Prepare_stmtContext ctx); + void exitAlter_extension_opt_list(PostgreSqlParser.Alter_extension_opt_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#prepare_transaction_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_extension_opt_item}. * @param ctx the parse tree */ - void enterPrepare_transaction_stmt(PostgreSqlParser.Prepare_transaction_stmtContext ctx); + void enterAlter_extension_opt_item(PostgreSqlParser.Alter_extension_opt_itemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#prepare_transaction_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_extension_opt_item}. * @param ctx the parse tree */ - void exitPrepare_transaction_stmt(PostgreSqlParser.Prepare_transaction_stmtContext ctx); + void exitAlter_extension_opt_item(PostgreSqlParser.Alter_extension_opt_itemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#reassign_owned_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterextensioncontentsstmt}. * @param ctx the parse tree */ - void enterReassign_owned_stmt(PostgreSqlParser.Reassign_owned_stmtContext ctx); + void enterAlterextensioncontentsstmt(PostgreSqlParser.AlterextensioncontentsstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#reassign_owned_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterextensioncontentsstmt}. * @param ctx the parse tree */ - void exitReassign_owned_stmt(PostgreSqlParser.Reassign_owned_stmtContext ctx); + void exitAlterextensioncontentsstmt(PostgreSqlParser.AlterextensioncontentsstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#refresh_materialized_view_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createfdwstmt}. * @param ctx the parse tree */ - void enterRefresh_materialized_view_stmt(PostgreSqlParser.Refresh_materialized_view_stmtContext ctx); + void enterCreatefdwstmt(PostgreSqlParser.CreatefdwstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#refresh_materialized_view_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createfdwstmt}. * @param ctx the parse tree */ - void exitRefresh_materialized_view_stmt(PostgreSqlParser.Refresh_materialized_view_stmtContext ctx); + void exitCreatefdwstmt(PostgreSqlParser.CreatefdwstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#reindex_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#fdw_option}. * @param ctx the parse tree */ - void enterReindex_stmt(PostgreSqlParser.Reindex_stmtContext ctx); + void enterFdw_option(PostgreSqlParser.Fdw_optionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#reindex_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#fdw_option}. * @param ctx the parse tree */ - void exitReindex_stmt(PostgreSqlParser.Reindex_stmtContext ctx); + void exitFdw_option(PostgreSqlParser.Fdw_optionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#release_savepoint_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#fdw_options}. * @param ctx the parse tree */ - void enterRelease_savepoint_stmt(PostgreSqlParser.Release_savepoint_stmtContext ctx); + void enterFdw_options(PostgreSqlParser.Fdw_optionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#release_savepoint_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#fdw_options}. * @param ctx the parse tree */ - void exitRelease_savepoint_stmt(PostgreSqlParser.Release_savepoint_stmtContext ctx); + void exitFdw_options(PostgreSqlParser.Fdw_optionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#reset_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_fdw_options}. * @param ctx the parse tree */ - void enterReset_stmt(PostgreSqlParser.Reset_stmtContext ctx); + void enterOpt_fdw_options(PostgreSqlParser.Opt_fdw_optionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#reset_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_fdw_options}. * @param ctx the parse tree */ - void exitReset_stmt(PostgreSqlParser.Reset_stmtContext ctx); + void exitOpt_fdw_options(PostgreSqlParser.Opt_fdw_optionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#revoke_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterfdwstmt}. * @param ctx the parse tree */ - void enterRevoke_stmt(PostgreSqlParser.Revoke_stmtContext ctx); + void enterAlterfdwstmt(PostgreSqlParser.AlterfdwstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#revoke_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterfdwstmt}. * @param ctx the parse tree */ - void exitRevoke_stmt(PostgreSqlParser.Revoke_stmtContext ctx); + void exitAlterfdwstmt(PostgreSqlParser.AlterfdwstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#rollback_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#create_generic_options}. * @param ctx the parse tree */ - void enterRollback_stmt(PostgreSqlParser.Rollback_stmtContext ctx); + void enterCreate_generic_options(PostgreSqlParser.Create_generic_optionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#rollback_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#create_generic_options}. * @param ctx the parse tree */ - void exitRollback_stmt(PostgreSqlParser.Rollback_stmtContext ctx); + void exitCreate_generic_options(PostgreSqlParser.Create_generic_optionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#rollback_prepared_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#generic_option_list}. * @param ctx the parse tree */ - void enterRollback_prepared_stmt(PostgreSqlParser.Rollback_prepared_stmtContext ctx); + void enterGeneric_option_list(PostgreSqlParser.Generic_option_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#rollback_prepared_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#generic_option_list}. * @param ctx the parse tree */ - void exitRollback_prepared_stmt(PostgreSqlParser.Rollback_prepared_stmtContext ctx); + void exitGeneric_option_list(PostgreSqlParser.Generic_option_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#rollback_to_savepoint_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_generic_options}. * @param ctx the parse tree */ - void enterRollback_to_savepoint_stmt(PostgreSqlParser.Rollback_to_savepoint_stmtContext ctx); + void enterAlter_generic_options(PostgreSqlParser.Alter_generic_optionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#rollback_to_savepoint_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_generic_options}. * @param ctx the parse tree */ - void exitRollback_to_savepoint_stmt(PostgreSqlParser.Rollback_to_savepoint_stmtContext ctx); + void exitAlter_generic_options(PostgreSqlParser.Alter_generic_optionsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#savepoint_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_generic_option_list}. * @param ctx the parse tree */ - void enterSavepoint_stmt(PostgreSqlParser.Savepoint_stmtContext ctx); + void enterAlter_generic_option_list(PostgreSqlParser.Alter_generic_option_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#savepoint_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_generic_option_list}. * @param ctx the parse tree */ - void exitSavepoint_stmt(PostgreSqlParser.Savepoint_stmtContext ctx); + void exitAlter_generic_option_list(PostgreSqlParser.Alter_generic_option_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#security_label_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alter_generic_option_elem}. * @param ctx the parse tree */ - void enterSecurity_label_stmt(PostgreSqlParser.Security_label_stmtContext ctx); + void enterAlter_generic_option_elem(PostgreSqlParser.Alter_generic_option_elemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#security_label_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alter_generic_option_elem}. * @param ctx the parse tree */ - void exitSecurity_label_stmt(PostgreSqlParser.Security_label_stmtContext ctx); + void exitAlter_generic_option_elem(PostgreSqlParser.Alter_generic_option_elemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#select_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#generic_option_elem}. * @param ctx the parse tree */ - void enterSelect_stmt(PostgreSqlParser.Select_stmtContext ctx); + void enterGeneric_option_elem(PostgreSqlParser.Generic_option_elemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#select_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#generic_option_elem}. * @param ctx the parse tree */ - void exitSelect_stmt(PostgreSqlParser.Select_stmtContext ctx); + void exitGeneric_option_elem(PostgreSqlParser.Generic_option_elemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#select_into_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#generic_option_name}. * @param ctx the parse tree */ - void enterSelect_into_stmt(PostgreSqlParser.Select_into_stmtContext ctx); + void enterGeneric_option_name(PostgreSqlParser.Generic_option_nameContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#select_into_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#generic_option_name}. * @param ctx the parse tree */ - void exitSelect_into_stmt(PostgreSqlParser.Select_into_stmtContext ctx); + void exitGeneric_option_name(PostgreSqlParser.Generic_option_nameContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#with_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#generic_option_arg}. * @param ctx the parse tree */ - void enterWith_clause(PostgreSqlParser.With_clauseContext ctx); + void enterGeneric_option_arg(PostgreSqlParser.Generic_option_argContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#with_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#generic_option_arg}. * @param ctx the parse tree */ - void exitWith_clause(PostgreSqlParser.With_clauseContext ctx); + void exitGeneric_option_arg(PostgreSqlParser.Generic_option_argContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#with_expr}. + * Enter a parse tree produced by {@link PostgreSqlParser#createforeignserverstmt}. * @param ctx the parse tree */ - void enterWith_expr(PostgreSqlParser.With_exprContext ctx); + void enterCreateforeignserverstmt(PostgreSqlParser.CreateforeignserverstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#with_expr}. + * Exit a parse tree produced by {@link PostgreSqlParser#createforeignserverstmt}. * @param ctx the parse tree */ - void exitWith_expr(PostgreSqlParser.With_exprContext ctx); + void exitCreateforeignserverstmt(PostgreSqlParser.CreateforeignserverstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#set_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_type}. * @param ctx the parse tree */ - void enterSet_stmt(PostgreSqlParser.Set_stmtContext ctx); + void enterOpt_type(PostgreSqlParser.Opt_typeContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#set_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_type}. * @param ctx the parse tree */ - void exitSet_stmt(PostgreSqlParser.Set_stmtContext ctx); + void exitOpt_type(PostgreSqlParser.Opt_typeContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#set_constraints_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#foreign_server_version}. * @param ctx the parse tree */ - void enterSet_constraints_stmt(PostgreSqlParser.Set_constraints_stmtContext ctx); + void enterForeign_server_version(PostgreSqlParser.Foreign_server_versionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#set_constraints_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#foreign_server_version}. * @param ctx the parse tree */ - void exitSet_constraints_stmt(PostgreSqlParser.Set_constraints_stmtContext ctx); + void exitForeign_server_version(PostgreSqlParser.Foreign_server_versionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#set_role_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_foreign_server_version}. * @param ctx the parse tree */ - void enterSet_role_stmt(PostgreSqlParser.Set_role_stmtContext ctx); + void enterOpt_foreign_server_version(PostgreSqlParser.Opt_foreign_server_versionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#set_role_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_foreign_server_version}. * @param ctx the parse tree */ - void exitSet_role_stmt(PostgreSqlParser.Set_role_stmtContext ctx); + void exitOpt_foreign_server_version(PostgreSqlParser.Opt_foreign_server_versionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#set_session_authorization_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterforeignserverstmt}. * @param ctx the parse tree */ - void enterSet_session_authorization_stmt(PostgreSqlParser.Set_session_authorization_stmtContext ctx); + void enterAlterforeignserverstmt(PostgreSqlParser.AlterforeignserverstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#set_session_authorization_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterforeignserverstmt}. * @param ctx the parse tree */ - void exitSet_session_authorization_stmt(PostgreSqlParser.Set_session_authorization_stmtContext ctx); + void exitAlterforeignserverstmt(PostgreSqlParser.AlterforeignserverstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#transaction_mode}. + * Enter a parse tree produced by {@link PostgreSqlParser#createforeigntablestmt}. * @param ctx the parse tree */ - void enterTransaction_mode(PostgreSqlParser.Transaction_modeContext ctx); + void enterCreateforeigntablestmt(PostgreSqlParser.CreateforeigntablestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#transaction_mode}. + * Exit a parse tree produced by {@link PostgreSqlParser#createforeigntablestmt}. * @param ctx the parse tree */ - void exitTransaction_mode(PostgreSqlParser.Transaction_modeContext ctx); + void exitCreateforeigntablestmt(PostgreSqlParser.CreateforeigntablestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#importforeignschemastmt}. + * @param ctx the parse tree + */ + void enterImportforeignschemastmt(PostgreSqlParser.ImportforeignschemastmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#importforeignschemastmt}. + * @param ctx the parse tree + */ + void exitImportforeignschemastmt(PostgreSqlParser.ImportforeignschemastmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#import_qualification_type}. + * @param ctx the parse tree + */ + void enterImport_qualification_type(PostgreSqlParser.Import_qualification_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#import_qualification_type}. + * @param ctx the parse tree + */ + void exitImport_qualification_type(PostgreSqlParser.Import_qualification_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#import_qualification}. + * @param ctx the parse tree + */ + void enterImport_qualification(PostgreSqlParser.Import_qualificationContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#import_qualification}. + * @param ctx the parse tree + */ + void exitImport_qualification(PostgreSqlParser.Import_qualificationContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createusermappingstmt}. + * @param ctx the parse tree + */ + void enterCreateusermappingstmt(PostgreSqlParser.CreateusermappingstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createusermappingstmt}. + * @param ctx the parse tree + */ + void exitCreateusermappingstmt(PostgreSqlParser.CreateusermappingstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#auth_ident}. + * @param ctx the parse tree + */ + void enterAuth_ident(PostgreSqlParser.Auth_identContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#auth_ident}. + * @param ctx the parse tree + */ + void exitAuth_ident(PostgreSqlParser.Auth_identContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dropusermappingstmt}. + * @param ctx the parse tree + */ + void enterDropusermappingstmt(PostgreSqlParser.DropusermappingstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dropusermappingstmt}. + * @param ctx the parse tree + */ + void exitDropusermappingstmt(PostgreSqlParser.DropusermappingstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterusermappingstmt}. + * @param ctx the parse tree + */ + void enterAlterusermappingstmt(PostgreSqlParser.AlterusermappingstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterusermappingstmt}. + * @param ctx the parse tree + */ + void exitAlterusermappingstmt(PostgreSqlParser.AlterusermappingstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createpolicystmt}. + * @param ctx the parse tree + */ + void enterCreatepolicystmt(PostgreSqlParser.CreatepolicystmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createpolicystmt}. + * @param ctx the parse tree + */ + void exitCreatepolicystmt(PostgreSqlParser.CreatepolicystmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterpolicystmt}. + * @param ctx the parse tree + */ + void enterAlterpolicystmt(PostgreSqlParser.AlterpolicystmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterpolicystmt}. + * @param ctx the parse tree + */ + void exitAlterpolicystmt(PostgreSqlParser.AlterpolicystmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rowsecurityoptionalexpr}. + * @param ctx the parse tree + */ + void enterRowsecurityoptionalexpr(PostgreSqlParser.RowsecurityoptionalexprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rowsecurityoptionalexpr}. + * @param ctx the parse tree + */ + void exitRowsecurityoptionalexpr(PostgreSqlParser.RowsecurityoptionalexprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rowsecurityoptionalwithcheck}. + * @param ctx the parse tree + */ + void enterRowsecurityoptionalwithcheck(PostgreSqlParser.RowsecurityoptionalwithcheckContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rowsecurityoptionalwithcheck}. + * @param ctx the parse tree + */ + void exitRowsecurityoptionalwithcheck(PostgreSqlParser.RowsecurityoptionalwithcheckContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rowsecuritydefaulttorole}. + * @param ctx the parse tree + */ + void enterRowsecuritydefaulttorole(PostgreSqlParser.RowsecuritydefaulttoroleContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rowsecuritydefaulttorole}. + * @param ctx the parse tree + */ + void exitRowsecuritydefaulttorole(PostgreSqlParser.RowsecuritydefaulttoroleContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rowsecurityoptionaltorole}. + * @param ctx the parse tree + */ + void enterRowsecurityoptionaltorole(PostgreSqlParser.RowsecurityoptionaltoroleContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rowsecurityoptionaltorole}. + * @param ctx the parse tree + */ + void exitRowsecurityoptionaltorole(PostgreSqlParser.RowsecurityoptionaltoroleContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rowsecuritydefaultpermissive}. + * @param ctx the parse tree + */ + void enterRowsecuritydefaultpermissive(PostgreSqlParser.RowsecuritydefaultpermissiveContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rowsecuritydefaultpermissive}. + * @param ctx the parse tree + */ + void exitRowsecuritydefaultpermissive(PostgreSqlParser.RowsecuritydefaultpermissiveContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rowsecuritydefaultforcmd}. + * @param ctx the parse tree + */ + void enterRowsecuritydefaultforcmd(PostgreSqlParser.RowsecuritydefaultforcmdContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rowsecuritydefaultforcmd}. + * @param ctx the parse tree + */ + void exitRowsecuritydefaultforcmd(PostgreSqlParser.RowsecuritydefaultforcmdContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#row_security_cmd}. + * @param ctx the parse tree + */ + void enterRow_security_cmd(PostgreSqlParser.Row_security_cmdContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#row_security_cmd}. + * @param ctx the parse tree + */ + void exitRow_security_cmd(PostgreSqlParser.Row_security_cmdContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createamstmt}. + * @param ctx the parse tree + */ + void enterCreateamstmt(PostgreSqlParser.CreateamstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createamstmt}. + * @param ctx the parse tree + */ + void exitCreateamstmt(PostgreSqlParser.CreateamstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#am_type}. + * @param ctx the parse tree + */ + void enterAm_type(PostgreSqlParser.Am_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#am_type}. + * @param ctx the parse tree + */ + void exitAm_type(PostgreSqlParser.Am_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createtrigstmt}. + * @param ctx the parse tree + */ + void enterCreatetrigstmt(PostgreSqlParser.CreatetrigstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createtrigstmt}. + * @param ctx the parse tree + */ + void exitCreatetrigstmt(PostgreSqlParser.CreatetrigstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggeractiontime}. + * @param ctx the parse tree + */ + void enterTriggeractiontime(PostgreSqlParser.TriggeractiontimeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggeractiontime}. + * @param ctx the parse tree + */ + void exitTriggeractiontime(PostgreSqlParser.TriggeractiontimeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggerevents}. + * @param ctx the parse tree + */ + void enterTriggerevents(PostgreSqlParser.TriggereventsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggerevents}. + * @param ctx the parse tree + */ + void exitTriggerevents(PostgreSqlParser.TriggereventsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggeroneevent}. + * @param ctx the parse tree + */ + void enterTriggeroneevent(PostgreSqlParser.TriggeroneeventContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggeroneevent}. + * @param ctx the parse tree + */ + void exitTriggeroneevent(PostgreSqlParser.TriggeroneeventContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggerreferencing}. + * @param ctx the parse tree + */ + void enterTriggerreferencing(PostgreSqlParser.TriggerreferencingContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggerreferencing}. + * @param ctx the parse tree + */ + void exitTriggerreferencing(PostgreSqlParser.TriggerreferencingContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggertransitions}. + * @param ctx the parse tree + */ + void enterTriggertransitions(PostgreSqlParser.TriggertransitionsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggertransitions}. + * @param ctx the parse tree + */ + void exitTriggertransitions(PostgreSqlParser.TriggertransitionsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggertransition}. + * @param ctx the parse tree + */ + void enterTriggertransition(PostgreSqlParser.TriggertransitionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggertransition}. + * @param ctx the parse tree + */ + void exitTriggertransition(PostgreSqlParser.TriggertransitionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transitionoldornew}. + * @param ctx the parse tree + */ + void enterTransitionoldornew(PostgreSqlParser.TransitionoldornewContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transitionoldornew}. + * @param ctx the parse tree + */ + void exitTransitionoldornew(PostgreSqlParser.TransitionoldornewContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transitionrowortable}. + * @param ctx the parse tree + */ + void enterTransitionrowortable(PostgreSqlParser.TransitionrowortableContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transitionrowortable}. + * @param ctx the parse tree + */ + void exitTransitionrowortable(PostgreSqlParser.TransitionrowortableContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transitionrelname}. + * @param ctx the parse tree + */ + void enterTransitionrelname(PostgreSqlParser.TransitionrelnameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transitionrelname}. + * @param ctx the parse tree + */ + void exitTransitionrelname(PostgreSqlParser.TransitionrelnameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggerforspec}. + * @param ctx the parse tree + */ + void enterTriggerforspec(PostgreSqlParser.TriggerforspecContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggerforspec}. + * @param ctx the parse tree + */ + void exitTriggerforspec(PostgreSqlParser.TriggerforspecContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggerforopteach}. + * @param ctx the parse tree + */ + void enterTriggerforopteach(PostgreSqlParser.TriggerforopteachContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggerforopteach}. + * @param ctx the parse tree + */ + void exitTriggerforopteach(PostgreSqlParser.TriggerforopteachContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggerfortype}. + * @param ctx the parse tree + */ + void enterTriggerfortype(PostgreSqlParser.TriggerfortypeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggerfortype}. + * @param ctx the parse tree + */ + void exitTriggerfortype(PostgreSqlParser.TriggerfortypeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggerwhen}. + * @param ctx the parse tree + */ + void enterTriggerwhen(PostgreSqlParser.TriggerwhenContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggerwhen}. + * @param ctx the parse tree + */ + void exitTriggerwhen(PostgreSqlParser.TriggerwhenContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#function_or_procedure}. + * @param ctx the parse tree + */ + void enterFunction_or_procedure(PostgreSqlParser.Function_or_procedureContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#function_or_procedure}. + * @param ctx the parse tree + */ + void exitFunction_or_procedure(PostgreSqlParser.Function_or_procedureContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggerfuncargs}. + * @param ctx the parse tree + */ + void enterTriggerfuncargs(PostgreSqlParser.TriggerfuncargsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggerfuncargs}. + * @param ctx the parse tree + */ + void exitTriggerfuncargs(PostgreSqlParser.TriggerfuncargsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#triggerfuncarg}. + * @param ctx the parse tree + */ + void enterTriggerfuncarg(PostgreSqlParser.TriggerfuncargContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#triggerfuncarg}. + * @param ctx the parse tree + */ + void exitTriggerfuncarg(PostgreSqlParser.TriggerfuncargContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#optconstrfromtable}. + * @param ctx the parse tree + */ + void enterOptconstrfromtable(PostgreSqlParser.OptconstrfromtableContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#optconstrfromtable}. + * @param ctx the parse tree + */ + void exitOptconstrfromtable(PostgreSqlParser.OptconstrfromtableContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#constraintattributespec}. + * @param ctx the parse tree + */ + void enterConstraintattributespec(PostgreSqlParser.ConstraintattributespecContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#constraintattributespec}. + * @param ctx the parse tree + */ + void exitConstraintattributespec(PostgreSqlParser.ConstraintattributespecContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#constraintattributeElem}. + * @param ctx the parse tree + */ + void enterConstraintattributeElem(PostgreSqlParser.ConstraintattributeElemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#constraintattributeElem}. + * @param ctx the parse tree + */ + void exitConstraintattributeElem(PostgreSqlParser.ConstraintattributeElemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createeventtrigstmt}. + * @param ctx the parse tree + */ + void enterCreateeventtrigstmt(PostgreSqlParser.CreateeventtrigstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createeventtrigstmt}. + * @param ctx the parse tree + */ + void exitCreateeventtrigstmt(PostgreSqlParser.CreateeventtrigstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#event_trigger_when_list}. + * @param ctx the parse tree + */ + void enterEvent_trigger_when_list(PostgreSqlParser.Event_trigger_when_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#event_trigger_when_list}. + * @param ctx the parse tree + */ + void exitEvent_trigger_when_list(PostgreSqlParser.Event_trigger_when_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#event_trigger_when_item}. + * @param ctx the parse tree + */ + void enterEvent_trigger_when_item(PostgreSqlParser.Event_trigger_when_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#event_trigger_when_item}. + * @param ctx the parse tree + */ + void exitEvent_trigger_when_item(PostgreSqlParser.Event_trigger_when_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#event_trigger_value_list}. + * @param ctx the parse tree + */ + void enterEvent_trigger_value_list(PostgreSqlParser.Event_trigger_value_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#event_trigger_value_list}. + * @param ctx the parse tree + */ + void exitEvent_trigger_value_list(PostgreSqlParser.Event_trigger_value_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#altereventtrigstmt}. + * @param ctx the parse tree + */ + void enterAltereventtrigstmt(PostgreSqlParser.AltereventtrigstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#altereventtrigstmt}. + * @param ctx the parse tree + */ + void exitAltereventtrigstmt(PostgreSqlParser.AltereventtrigstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#enable_trigger}. + * @param ctx the parse tree + */ + void enterEnable_trigger(PostgreSqlParser.Enable_triggerContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#enable_trigger}. + * @param ctx the parse tree + */ + void exitEnable_trigger(PostgreSqlParser.Enable_triggerContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createassertionstmt}. + * @param ctx the parse tree + */ + void enterCreateassertionstmt(PostgreSqlParser.CreateassertionstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createassertionstmt}. + * @param ctx the parse tree + */ + void exitCreateassertionstmt(PostgreSqlParser.CreateassertionstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#definestmt}. + * @param ctx the parse tree + */ + void enterDefinestmt(PostgreSqlParser.DefinestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#definestmt}. + * @param ctx the parse tree + */ + void exitDefinestmt(PostgreSqlParser.DefinestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#definition}. + * @param ctx the parse tree + */ + void enterDefinition(PostgreSqlParser.DefinitionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#definition}. + * @param ctx the parse tree + */ + void exitDefinition(PostgreSqlParser.DefinitionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#def_list}. + * @param ctx the parse tree + */ + void enterDef_list(PostgreSqlParser.Def_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#def_list}. + * @param ctx the parse tree + */ + void exitDef_list(PostgreSqlParser.Def_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#def_elem}. + * @param ctx the parse tree + */ + void enterDef_elem(PostgreSqlParser.Def_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#def_elem}. + * @param ctx the parse tree + */ + void exitDef_elem(PostgreSqlParser.Def_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#def_arg}. + * @param ctx the parse tree + */ + void enterDef_arg(PostgreSqlParser.Def_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#def_arg}. + * @param ctx the parse tree + */ + void exitDef_arg(PostgreSqlParser.Def_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#old_aggr_definition}. + * @param ctx the parse tree + */ + void enterOld_aggr_definition(PostgreSqlParser.Old_aggr_definitionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#old_aggr_definition}. + * @param ctx the parse tree + */ + void exitOld_aggr_definition(PostgreSqlParser.Old_aggr_definitionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#old_aggr_list}. + * @param ctx the parse tree + */ + void enterOld_aggr_list(PostgreSqlParser.Old_aggr_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#old_aggr_list}. + * @param ctx the parse tree + */ + void exitOld_aggr_list(PostgreSqlParser.Old_aggr_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#old_aggr_elem}. + * @param ctx the parse tree + */ + void enterOld_aggr_elem(PostgreSqlParser.Old_aggr_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#old_aggr_elem}. + * @param ctx the parse tree + */ + void exitOld_aggr_elem(PostgreSqlParser.Old_aggr_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_enum_val_list}. + * @param ctx the parse tree + */ + void enterOpt_enum_val_list(PostgreSqlParser.Opt_enum_val_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_enum_val_list}. + * @param ctx the parse tree + */ + void exitOpt_enum_val_list(PostgreSqlParser.Opt_enum_val_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#enum_val_list}. + * @param ctx the parse tree + */ + void enterEnum_val_list(PostgreSqlParser.Enum_val_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#enum_val_list}. + * @param ctx the parse tree + */ + void exitEnum_val_list(PostgreSqlParser.Enum_val_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterenumstmt}. + * @param ctx the parse tree + */ + void enterAlterenumstmt(PostgreSqlParser.AlterenumstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterenumstmt}. + * @param ctx the parse tree + */ + void exitAlterenumstmt(PostgreSqlParser.AlterenumstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_if_not_exists}. + * @param ctx the parse tree + */ + void enterOpt_if_not_exists(PostgreSqlParser.Opt_if_not_existsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_if_not_exists}. + * @param ctx the parse tree + */ + void exitOpt_if_not_exists(PostgreSqlParser.Opt_if_not_existsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createopclassstmt}. + * @param ctx the parse tree + */ + void enterCreateopclassstmt(PostgreSqlParser.CreateopclassstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createopclassstmt}. + * @param ctx the parse tree + */ + void exitCreateopclassstmt(PostgreSqlParser.CreateopclassstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opclass_item_list}. + * @param ctx the parse tree + */ + void enterOpclass_item_list(PostgreSqlParser.Opclass_item_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opclass_item_list}. + * @param ctx the parse tree + */ + void exitOpclass_item_list(PostgreSqlParser.Opclass_item_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opclass_item}. + * @param ctx the parse tree + */ + void enterOpclass_item(PostgreSqlParser.Opclass_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opclass_item}. + * @param ctx the parse tree + */ + void exitOpclass_item(PostgreSqlParser.Opclass_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_default}. + * @param ctx the parse tree + */ + void enterOpt_default(PostgreSqlParser.Opt_defaultContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_default}. + * @param ctx the parse tree + */ + void exitOpt_default(PostgreSqlParser.Opt_defaultContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_opfamily}. + * @param ctx the parse tree + */ + void enterOpt_opfamily(PostgreSqlParser.Opt_opfamilyContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_opfamily}. + * @param ctx the parse tree + */ + void exitOpt_opfamily(PostgreSqlParser.Opt_opfamilyContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opclass_purpose}. + * @param ctx the parse tree + */ + void enterOpclass_purpose(PostgreSqlParser.Opclass_purposeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opclass_purpose}. + * @param ctx the parse tree + */ + void exitOpclass_purpose(PostgreSqlParser.Opclass_purposeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_recheck}. + * @param ctx the parse tree + */ + void enterOpt_recheck(PostgreSqlParser.Opt_recheckContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_recheck}. + * @param ctx the parse tree + */ + void exitOpt_recheck(PostgreSqlParser.Opt_recheckContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createopfamilystmt}. + * @param ctx the parse tree + */ + void enterCreateopfamilystmt(PostgreSqlParser.CreateopfamilystmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createopfamilystmt}. + * @param ctx the parse tree + */ + void exitCreateopfamilystmt(PostgreSqlParser.CreateopfamilystmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alteropfamilystmt}. + * @param ctx the parse tree + */ + void enterAlteropfamilystmt(PostgreSqlParser.AlteropfamilystmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alteropfamilystmt}. + * @param ctx the parse tree + */ + void exitAlteropfamilystmt(PostgreSqlParser.AlteropfamilystmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opclass_drop_list}. + * @param ctx the parse tree + */ + void enterOpclass_drop_list(PostgreSqlParser.Opclass_drop_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opclass_drop_list}. + * @param ctx the parse tree + */ + void exitOpclass_drop_list(PostgreSqlParser.Opclass_drop_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opclass_drop}. + * @param ctx the parse tree + */ + void enterOpclass_drop(PostgreSqlParser.Opclass_dropContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opclass_drop}. + * @param ctx the parse tree + */ + void exitOpclass_drop(PostgreSqlParser.Opclass_dropContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dropopclassstmt}. + * @param ctx the parse tree + */ + void enterDropopclassstmt(PostgreSqlParser.DropopclassstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dropopclassstmt}. + * @param ctx the parse tree + */ + void exitDropopclassstmt(PostgreSqlParser.DropopclassstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dropopfamilystmt}. + * @param ctx the parse tree + */ + void enterDropopfamilystmt(PostgreSqlParser.DropopfamilystmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dropopfamilystmt}. + * @param ctx the parse tree + */ + void exitDropopfamilystmt(PostgreSqlParser.DropopfamilystmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dropownedstmt}. + * @param ctx the parse tree + */ + void enterDropownedstmt(PostgreSqlParser.DropownedstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dropownedstmt}. + * @param ctx the parse tree + */ + void exitDropownedstmt(PostgreSqlParser.DropownedstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reassignownedstmt}. + * @param ctx the parse tree + */ + void enterReassignownedstmt(PostgreSqlParser.ReassignownedstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reassignownedstmt}. + * @param ctx the parse tree + */ + void exitReassignownedstmt(PostgreSqlParser.ReassignownedstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dropstmt}. + * @param ctx the parse tree + */ + void enterDropstmt(PostgreSqlParser.DropstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dropstmt}. + * @param ctx the parse tree + */ + void exitDropstmt(PostgreSqlParser.DropstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#object_type_any_name}. + * @param ctx the parse tree + */ + void enterObject_type_any_name(PostgreSqlParser.Object_type_any_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#object_type_any_name}. + * @param ctx the parse tree + */ + void exitObject_type_any_name(PostgreSqlParser.Object_type_any_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#object_type_name}. + * @param ctx the parse tree + */ + void enterObject_type_name(PostgreSqlParser.Object_type_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#object_type_name}. + * @param ctx the parse tree + */ + void exitObject_type_name(PostgreSqlParser.Object_type_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_type_name}. + * @param ctx the parse tree + */ + void enterDrop_type_name(PostgreSqlParser.Drop_type_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_type_name}. + * @param ctx the parse tree + */ + void exitDrop_type_name(PostgreSqlParser.Drop_type_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#object_type_name_on_any_name}. + * @param ctx the parse tree + */ + void enterObject_type_name_on_any_name(PostgreSqlParser.Object_type_name_on_any_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#object_type_name_on_any_name}. + * @param ctx the parse tree + */ + void exitObject_type_name_on_any_name(PostgreSqlParser.Object_type_name_on_any_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#any_name_list}. + * @param ctx the parse tree + */ + void enterAny_name_list(PostgreSqlParser.Any_name_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#any_name_list}. + * @param ctx the parse tree + */ + void exitAny_name_list(PostgreSqlParser.Any_name_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#any_name}. + * @param ctx the parse tree + */ + void enterAny_name(PostgreSqlParser.Any_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#any_name}. + * @param ctx the parse tree + */ + void exitAny_name(PostgreSqlParser.Any_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#attrs}. + * @param ctx the parse tree + */ + void enterAttrs(PostgreSqlParser.AttrsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#attrs}. + * @param ctx the parse tree + */ + void exitAttrs(PostgreSqlParser.AttrsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#type_name_list}. + * @param ctx the parse tree + */ + void enterType_name_list(PostgreSqlParser.Type_name_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#type_name_list}. + * @param ctx the parse tree + */ + void exitType_name_list(PostgreSqlParser.Type_name_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#truncatestmt}. + * @param ctx the parse tree + */ + void enterTruncatestmt(PostgreSqlParser.TruncatestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#truncatestmt}. + * @param ctx the parse tree + */ + void exitTruncatestmt(PostgreSqlParser.TruncatestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_restart_seqs}. + * @param ctx the parse tree + */ + void enterOpt_restart_seqs(PostgreSqlParser.Opt_restart_seqsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_restart_seqs}. + * @param ctx the parse tree + */ + void exitOpt_restart_seqs(PostgreSqlParser.Opt_restart_seqsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#commentstmt}. + * @param ctx the parse tree + */ + void enterCommentstmt(PostgreSqlParser.CommentstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#commentstmt}. + * @param ctx the parse tree + */ + void exitCommentstmt(PostgreSqlParser.CommentstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#comment_text}. + * @param ctx the parse tree + */ + void enterComment_text(PostgreSqlParser.Comment_textContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#comment_text}. + * @param ctx the parse tree + */ + void exitComment_text(PostgreSqlParser.Comment_textContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#seclabelstmt}. + * @param ctx the parse tree + */ + void enterSeclabelstmt(PostgreSqlParser.SeclabelstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#seclabelstmt}. + * @param ctx the parse tree + */ + void exitSeclabelstmt(PostgreSqlParser.SeclabelstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_provider}. + * @param ctx the parse tree + */ + void enterOpt_provider(PostgreSqlParser.Opt_providerContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_provider}. + * @param ctx the parse tree + */ + void exitOpt_provider(PostgreSqlParser.Opt_providerContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#security_label}. + * @param ctx the parse tree + */ + void enterSecurity_label(PostgreSqlParser.Security_labelContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#security_label}. + * @param ctx the parse tree + */ + void exitSecurity_label(PostgreSqlParser.Security_labelContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#fetchstmt}. + * @param ctx the parse tree + */ + void enterFetchstmt(PostgreSqlParser.FetchstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#fetchstmt}. + * @param ctx the parse tree + */ + void exitFetchstmt(PostgreSqlParser.FetchstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#fetch_args}. + * @param ctx the parse tree + */ + void enterFetch_args(PostgreSqlParser.Fetch_argsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#fetch_args}. + * @param ctx the parse tree + */ + void exitFetch_args(PostgreSqlParser.Fetch_argsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#from_in}. + * @param ctx the parse tree + */ + void enterFrom_in(PostgreSqlParser.From_inContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#from_in}. + * @param ctx the parse tree + */ + void exitFrom_in(PostgreSqlParser.From_inContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_from_in}. + * @param ctx the parse tree + */ + void enterOpt_from_in(PostgreSqlParser.Opt_from_inContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_from_in}. + * @param ctx the parse tree + */ + void exitOpt_from_in(PostgreSqlParser.Opt_from_inContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#grantstmt}. + * @param ctx the parse tree + */ + void enterGrantstmt(PostgreSqlParser.GrantstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#grantstmt}. + * @param ctx the parse tree + */ + void exitGrantstmt(PostgreSqlParser.GrantstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#revokestmt}. + * @param ctx the parse tree + */ + void enterRevokestmt(PostgreSqlParser.RevokestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#revokestmt}. + * @param ctx the parse tree + */ + void exitRevokestmt(PostgreSqlParser.RevokestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#privileges}. + * @param ctx the parse tree + */ + void enterPrivileges(PostgreSqlParser.PrivilegesContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#privileges}. + * @param ctx the parse tree + */ + void exitPrivileges(PostgreSqlParser.PrivilegesContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#privilege_list}. + * @param ctx the parse tree + */ + void enterPrivilege_list(PostgreSqlParser.Privilege_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#privilege_list}. + * @param ctx the parse tree + */ + void exitPrivilege_list(PostgreSqlParser.Privilege_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#privilege}. + * @param ctx the parse tree + */ + void enterPrivilege(PostgreSqlParser.PrivilegeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#privilege}. + * @param ctx the parse tree + */ + void exitPrivilege(PostgreSqlParser.PrivilegeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#privilege_target}. + * @param ctx the parse tree + */ + void enterPrivilege_target(PostgreSqlParser.Privilege_targetContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#privilege_target}. + * @param ctx the parse tree + */ + void exitPrivilege_target(PostgreSqlParser.Privilege_targetContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#grantee_list}. + * @param ctx the parse tree + */ + void enterGrantee_list(PostgreSqlParser.Grantee_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#grantee_list}. + * @param ctx the parse tree + */ + void exitGrantee_list(PostgreSqlParser.Grantee_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#grantee}. + * @param ctx the parse tree + */ + void enterGrantee(PostgreSqlParser.GranteeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#grantee}. + * @param ctx the parse tree + */ + void exitGrantee(PostgreSqlParser.GranteeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_grant_grant_option}. + * @param ctx the parse tree + */ + void enterOpt_grant_grant_option(PostgreSqlParser.Opt_grant_grant_optionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_grant_grant_option}. + * @param ctx the parse tree + */ + void exitOpt_grant_grant_option(PostgreSqlParser.Opt_grant_grant_optionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#grantrolestmt}. + * @param ctx the parse tree + */ + void enterGrantrolestmt(PostgreSqlParser.GrantrolestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#grantrolestmt}. + * @param ctx the parse tree + */ + void exitGrantrolestmt(PostgreSqlParser.GrantrolestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#revokerolestmt}. + * @param ctx the parse tree + */ + void enterRevokerolestmt(PostgreSqlParser.RevokerolestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#revokerolestmt}. + * @param ctx the parse tree + */ + void exitRevokerolestmt(PostgreSqlParser.RevokerolestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_grant_admin_option}. + * @param ctx the parse tree + */ + void enterOpt_grant_admin_option(PostgreSqlParser.Opt_grant_admin_optionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_grant_admin_option}. + * @param ctx the parse tree + */ + void exitOpt_grant_admin_option(PostgreSqlParser.Opt_grant_admin_optionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_granted_by}. + * @param ctx the parse tree + */ + void enterOpt_granted_by(PostgreSqlParser.Opt_granted_byContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_granted_by}. + * @param ctx the parse tree + */ + void exitOpt_granted_by(PostgreSqlParser.Opt_granted_byContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterdefaultprivilegesstmt}. + * @param ctx the parse tree + */ + void enterAlterdefaultprivilegesstmt(PostgreSqlParser.AlterdefaultprivilegesstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterdefaultprivilegesstmt}. + * @param ctx the parse tree + */ + void exitAlterdefaultprivilegesstmt(PostgreSqlParser.AlterdefaultprivilegesstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#defacloptionlist}. + * @param ctx the parse tree + */ + void enterDefacloptionlist(PostgreSqlParser.DefacloptionlistContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#defacloptionlist}. + * @param ctx the parse tree + */ + void exitDefacloptionlist(PostgreSqlParser.DefacloptionlistContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#defacloption}. + * @param ctx the parse tree + */ + void enterDefacloption(PostgreSqlParser.DefacloptionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#defacloption}. + * @param ctx the parse tree + */ + void exitDefacloption(PostgreSqlParser.DefacloptionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#defaclaction}. + * @param ctx the parse tree + */ + void enterDefaclaction(PostgreSqlParser.DefaclactionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#defaclaction}. + * @param ctx the parse tree + */ + void exitDefaclaction(PostgreSqlParser.DefaclactionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#defacl_privilege_target}. + * @param ctx the parse tree + */ + void enterDefacl_privilege_target(PostgreSqlParser.Defacl_privilege_targetContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#defacl_privilege_target}. + * @param ctx the parse tree + */ + void exitDefacl_privilege_target(PostgreSqlParser.Defacl_privilege_targetContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#indexstmt}. + * @param ctx the parse tree + */ + void enterIndexstmt(PostgreSqlParser.IndexstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#indexstmt}. + * @param ctx the parse tree + */ + void exitIndexstmt(PostgreSqlParser.IndexstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_unique}. + * @param ctx the parse tree + */ + void enterOpt_unique(PostgreSqlParser.Opt_uniqueContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_unique}. + * @param ctx the parse tree + */ + void exitOpt_unique(PostgreSqlParser.Opt_uniqueContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_concurrently}. + * @param ctx the parse tree + */ + void enterOpt_concurrently(PostgreSqlParser.Opt_concurrentlyContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_concurrently}. + * @param ctx the parse tree + */ + void exitOpt_concurrently(PostgreSqlParser.Opt_concurrentlyContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_index_name}. + * @param ctx the parse tree + */ + void enterOpt_index_name(PostgreSqlParser.Opt_index_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_index_name}. + * @param ctx the parse tree + */ + void exitOpt_index_name(PostgreSqlParser.Opt_index_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#access_method_clause}. + * @param ctx the parse tree + */ + void enterAccess_method_clause(PostgreSqlParser.Access_method_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#access_method_clause}. + * @param ctx the parse tree + */ + void exitAccess_method_clause(PostgreSqlParser.Access_method_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#index_params}. + * @param ctx the parse tree + */ + void enterIndex_params(PostgreSqlParser.Index_paramsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#index_params}. + * @param ctx the parse tree + */ + void exitIndex_params(PostgreSqlParser.Index_paramsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#index_elem_options}. + * @param ctx the parse tree + */ + void enterIndex_elem_options(PostgreSqlParser.Index_elem_optionsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#index_elem_options}. + * @param ctx the parse tree + */ + void exitIndex_elem_options(PostgreSqlParser.Index_elem_optionsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#index_elem}. + * @param ctx the parse tree + */ + void enterIndex_elem(PostgreSqlParser.Index_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#index_elem}. + * @param ctx the parse tree + */ + void exitIndex_elem(PostgreSqlParser.Index_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_include}. + * @param ctx the parse tree + */ + void enterOpt_include(PostgreSqlParser.Opt_includeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_include}. + * @param ctx the parse tree + */ + void exitOpt_include(PostgreSqlParser.Opt_includeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#index_including_params}. + * @param ctx the parse tree + */ + void enterIndex_including_params(PostgreSqlParser.Index_including_paramsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#index_including_params}. + * @param ctx the parse tree + */ + void exitIndex_including_params(PostgreSqlParser.Index_including_paramsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_collate}. + * @param ctx the parse tree + */ + void enterOpt_collate(PostgreSqlParser.Opt_collateContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_collate}. + * @param ctx the parse tree + */ + void exitOpt_collate(PostgreSqlParser.Opt_collateContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_class}. + * @param ctx the parse tree + */ + void enterOpt_class(PostgreSqlParser.Opt_classContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_class}. + * @param ctx the parse tree + */ + void exitOpt_class(PostgreSqlParser.Opt_classContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_asc_desc}. + * @param ctx the parse tree + */ + void enterOpt_asc_desc(PostgreSqlParser.Opt_asc_descContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_asc_desc}. + * @param ctx the parse tree + */ + void exitOpt_asc_desc(PostgreSqlParser.Opt_asc_descContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_nulls_order}. + * @param ctx the parse tree + */ + void enterOpt_nulls_order(PostgreSqlParser.Opt_nulls_orderContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_nulls_order}. + * @param ctx the parse tree + */ + void exitOpt_nulls_order(PostgreSqlParser.Opt_nulls_orderContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createfunctionstmt}. + * @param ctx the parse tree + */ + void enterCreatefunctionstmt(PostgreSqlParser.CreatefunctionstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createfunctionstmt}. + * @param ctx the parse tree + */ + void exitCreatefunctionstmt(PostgreSqlParser.CreatefunctionstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_or_replace}. + * @param ctx the parse tree + */ + void enterOpt_or_replace(PostgreSqlParser.Opt_or_replaceContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_or_replace}. + * @param ctx the parse tree + */ + void exitOpt_or_replace(PostgreSqlParser.Opt_or_replaceContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_args}. + * @param ctx the parse tree + */ + void enterFunc_args(PostgreSqlParser.Func_argsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_args}. + * @param ctx the parse tree + */ + void exitFunc_args(PostgreSqlParser.Func_argsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_args_list}. + * @param ctx the parse tree + */ + void enterFunc_args_list(PostgreSqlParser.Func_args_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_args_list}. + * @param ctx the parse tree + */ + void exitFunc_args_list(PostgreSqlParser.Func_args_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#function_with_argtypes_list}. + * @param ctx the parse tree + */ + void enterFunction_with_argtypes_list(PostgreSqlParser.Function_with_argtypes_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#function_with_argtypes_list}. + * @param ctx the parse tree + */ + void exitFunction_with_argtypes_list(PostgreSqlParser.Function_with_argtypes_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#function_with_argtypes}. + * @param ctx the parse tree + */ + void enterFunction_with_argtypes(PostgreSqlParser.Function_with_argtypesContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#function_with_argtypes}. + * @param ctx the parse tree + */ + void exitFunction_with_argtypes(PostgreSqlParser.Function_with_argtypesContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_args_with_defaults}. + * @param ctx the parse tree + */ + void enterFunc_args_with_defaults(PostgreSqlParser.Func_args_with_defaultsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_args_with_defaults}. + * @param ctx the parse tree + */ + void exitFunc_args_with_defaults(PostgreSqlParser.Func_args_with_defaultsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_args_with_defaults_list}. + * @param ctx the parse tree + */ + void enterFunc_args_with_defaults_list(PostgreSqlParser.Func_args_with_defaults_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_args_with_defaults_list}. + * @param ctx the parse tree + */ + void exitFunc_args_with_defaults_list(PostgreSqlParser.Func_args_with_defaults_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_arg}. + * @param ctx the parse tree + */ + void enterFunc_arg(PostgreSqlParser.Func_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_arg}. + * @param ctx the parse tree + */ + void exitFunc_arg(PostgreSqlParser.Func_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#arg_class}. + * @param ctx the parse tree + */ + void enterArg_class(PostgreSqlParser.Arg_classContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#arg_class}. + * @param ctx the parse tree + */ + void exitArg_class(PostgreSqlParser.Arg_classContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#param_name}. + * @param ctx the parse tree + */ + void enterParam_name(PostgreSqlParser.Param_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#param_name}. + * @param ctx the parse tree + */ + void exitParam_name(PostgreSqlParser.Param_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_return}. + * @param ctx the parse tree + */ + void enterFunc_return(PostgreSqlParser.Func_returnContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_return}. + * @param ctx the parse tree + */ + void exitFunc_return(PostgreSqlParser.Func_returnContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_type}. + * @param ctx the parse tree + */ + void enterFunc_type(PostgreSqlParser.Func_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_type}. + * @param ctx the parse tree + */ + void exitFunc_type(PostgreSqlParser.Func_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_arg_with_default}. + * @param ctx the parse tree + */ + void enterFunc_arg_with_default(PostgreSqlParser.Func_arg_with_defaultContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_arg_with_default}. + * @param ctx the parse tree + */ + void exitFunc_arg_with_default(PostgreSqlParser.Func_arg_with_defaultContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#aggr_arg}. + * @param ctx the parse tree + */ + void enterAggr_arg(PostgreSqlParser.Aggr_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#aggr_arg}. + * @param ctx the parse tree + */ + void exitAggr_arg(PostgreSqlParser.Aggr_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#aggr_args}. + * @param ctx the parse tree + */ + void enterAggr_args(PostgreSqlParser.Aggr_argsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#aggr_args}. + * @param ctx the parse tree + */ + void exitAggr_args(PostgreSqlParser.Aggr_argsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#aggr_args_list}. + * @param ctx the parse tree + */ + void enterAggr_args_list(PostgreSqlParser.Aggr_args_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#aggr_args_list}. + * @param ctx the parse tree + */ + void exitAggr_args_list(PostgreSqlParser.Aggr_args_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#aggregate_with_argtypes}. + * @param ctx the parse tree + */ + void enterAggregate_with_argtypes(PostgreSqlParser.Aggregate_with_argtypesContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#aggregate_with_argtypes}. + * @param ctx the parse tree + */ + void exitAggregate_with_argtypes(PostgreSqlParser.Aggregate_with_argtypesContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#aggregate_with_argtypes_list}. + * @param ctx the parse tree + */ + void enterAggregate_with_argtypes_list(PostgreSqlParser.Aggregate_with_argtypes_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#aggregate_with_argtypes_list}. + * @param ctx the parse tree + */ + void exitAggregate_with_argtypes_list(PostgreSqlParser.Aggregate_with_argtypes_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createfunc_opt_list}. + * @param ctx the parse tree + */ + void enterCreatefunc_opt_list(PostgreSqlParser.Createfunc_opt_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createfunc_opt_list}. + * @param ctx the parse tree + */ + void exitCreatefunc_opt_list(PostgreSqlParser.Createfunc_opt_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#common_func_opt_item}. + * @param ctx the parse tree + */ + void enterCommon_func_opt_item(PostgreSqlParser.Common_func_opt_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#common_func_opt_item}. + * @param ctx the parse tree + */ + void exitCommon_func_opt_item(PostgreSqlParser.Common_func_opt_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createfunc_opt_item}. + * @param ctx the parse tree + */ + void enterCreatefunc_opt_item(PostgreSqlParser.Createfunc_opt_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createfunc_opt_item}. + * @param ctx the parse tree + */ + void exitCreatefunc_opt_item(PostgreSqlParser.Createfunc_opt_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_as}. + * @param ctx the parse tree + */ + void enterFunc_as(PostgreSqlParser.Func_asContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_as}. + * @param ctx the parse tree + */ + void exitFunc_as(PostgreSqlParser.Func_asContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transform_type_list}. + * @param ctx the parse tree + */ + void enterTransform_type_list(PostgreSqlParser.Transform_type_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transform_type_list}. + * @param ctx the parse tree + */ + void exitTransform_type_list(PostgreSqlParser.Transform_type_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_definition}. + * @param ctx the parse tree + */ + void enterOpt_definition(PostgreSqlParser.Opt_definitionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_definition}. + * @param ctx the parse tree + */ + void exitOpt_definition(PostgreSqlParser.Opt_definitionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#table_func_column}. + * @param ctx the parse tree + */ + void enterTable_func_column(PostgreSqlParser.Table_func_columnContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#table_func_column}. + * @param ctx the parse tree + */ + void exitTable_func_column(PostgreSqlParser.Table_func_columnContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#table_func_column_list}. + * @param ctx the parse tree + */ + void enterTable_func_column_list(PostgreSqlParser.Table_func_column_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#table_func_column_list}. + * @param ctx the parse tree + */ + void exitTable_func_column_list(PostgreSqlParser.Table_func_column_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterfunctionstmt}. + * @param ctx the parse tree + */ + void enterAlterfunctionstmt(PostgreSqlParser.AlterfunctionstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterfunctionstmt}. + * @param ctx the parse tree + */ + void exitAlterfunctionstmt(PostgreSqlParser.AlterfunctionstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterfunc_opt_list}. + * @param ctx the parse tree + */ + void enterAlterfunc_opt_list(PostgreSqlParser.Alterfunc_opt_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterfunc_opt_list}. + * @param ctx the parse tree + */ + void exitAlterfunc_opt_list(PostgreSqlParser.Alterfunc_opt_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_restrict}. + * @param ctx the parse tree + */ + void enterOpt_restrict(PostgreSqlParser.Opt_restrictContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_restrict}. + * @param ctx the parse tree + */ + void exitOpt_restrict(PostgreSqlParser.Opt_restrictContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#removefuncstmt}. + * @param ctx the parse tree + */ + void enterRemovefuncstmt(PostgreSqlParser.RemovefuncstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#removefuncstmt}. + * @param ctx the parse tree + */ + void exitRemovefuncstmt(PostgreSqlParser.RemovefuncstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#removeaggrstmt}. + * @param ctx the parse tree + */ + void enterRemoveaggrstmt(PostgreSqlParser.RemoveaggrstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#removeaggrstmt}. + * @param ctx the parse tree + */ + void exitRemoveaggrstmt(PostgreSqlParser.RemoveaggrstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#removeoperstmt}. + * @param ctx the parse tree + */ + void enterRemoveoperstmt(PostgreSqlParser.RemoveoperstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#removeoperstmt}. + * @param ctx the parse tree + */ + void exitRemoveoperstmt(PostgreSqlParser.RemoveoperstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#oper_argtypes}. + * @param ctx the parse tree + */ + void enterOper_argtypes(PostgreSqlParser.Oper_argtypesContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#oper_argtypes}. + * @param ctx the parse tree + */ + void exitOper_argtypes(PostgreSqlParser.Oper_argtypesContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#any_operator}. + * @param ctx the parse tree + */ + void enterAny_operator(PostgreSqlParser.Any_operatorContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#any_operator}. + * @param ctx the parse tree + */ + void exitAny_operator(PostgreSqlParser.Any_operatorContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#operator_with_argtypes_list}. + * @param ctx the parse tree + */ + void enterOperator_with_argtypes_list(PostgreSqlParser.Operator_with_argtypes_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#operator_with_argtypes_list}. + * @param ctx the parse tree + */ + void exitOperator_with_argtypes_list(PostgreSqlParser.Operator_with_argtypes_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#operator_with_argtypes}. + * @param ctx the parse tree + */ + void enterOperator_with_argtypes(PostgreSqlParser.Operator_with_argtypesContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#operator_with_argtypes}. + * @param ctx the parse tree + */ + void exitOperator_with_argtypes(PostgreSqlParser.Operator_with_argtypesContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dostmt}. + * @param ctx the parse tree + */ + void enterDostmt(PostgreSqlParser.DostmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dostmt}. + * @param ctx the parse tree + */ + void exitDostmt(PostgreSqlParser.DostmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dostmt_opt_list}. + * @param ctx the parse tree + */ + void enterDostmt_opt_list(PostgreSqlParser.Dostmt_opt_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dostmt_opt_list}. + * @param ctx the parse tree + */ + void exitDostmt_opt_list(PostgreSqlParser.Dostmt_opt_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dostmt_opt_item}. + * @param ctx the parse tree + */ + void enterDostmt_opt_item(PostgreSqlParser.Dostmt_opt_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dostmt_opt_item}. + * @param ctx the parse tree + */ + void exitDostmt_opt_item(PostgreSqlParser.Dostmt_opt_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createcaststmt}. + * @param ctx the parse tree + */ + void enterCreatecaststmt(PostgreSqlParser.CreatecaststmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createcaststmt}. + * @param ctx the parse tree + */ + void exitCreatecaststmt(PostgreSqlParser.CreatecaststmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#cast_context}. + * @param ctx the parse tree + */ + void enterCast_context(PostgreSqlParser.Cast_contextContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#cast_context}. + * @param ctx the parse tree + */ + void exitCast_context(PostgreSqlParser.Cast_contextContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dropcaststmt}. + * @param ctx the parse tree + */ + void enterDropcaststmt(PostgreSqlParser.DropcaststmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dropcaststmt}. + * @param ctx the parse tree + */ + void exitDropcaststmt(PostgreSqlParser.DropcaststmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_if_exists}. + * @param ctx the parse tree + */ + void enterOpt_if_exists(PostgreSqlParser.Opt_if_existsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_if_exists}. + * @param ctx the parse tree + */ + void exitOpt_if_exists(PostgreSqlParser.Opt_if_existsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createtransformstmt}. + * @param ctx the parse tree + */ + void enterCreatetransformstmt(PostgreSqlParser.CreatetransformstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createtransformstmt}. + * @param ctx the parse tree + */ + void exitCreatetransformstmt(PostgreSqlParser.CreatetransformstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transform_element_list}. + * @param ctx the parse tree + */ + void enterTransform_element_list(PostgreSqlParser.Transform_element_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transform_element_list}. + * @param ctx the parse tree + */ + void exitTransform_element_list(PostgreSqlParser.Transform_element_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#droptransformstmt}. + * @param ctx the parse tree + */ + void enterDroptransformstmt(PostgreSqlParser.DroptransformstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#droptransformstmt}. + * @param ctx the parse tree + */ + void exitDroptransformstmt(PostgreSqlParser.DroptransformstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reindexstmt}. + * @param ctx the parse tree + */ + void enterReindexstmt(PostgreSqlParser.ReindexstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reindexstmt}. + * @param ctx the parse tree + */ + void exitReindexstmt(PostgreSqlParser.ReindexstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reindex_target_type}. + * @param ctx the parse tree + */ + void enterReindex_target_type(PostgreSqlParser.Reindex_target_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reindex_target_type}. + * @param ctx the parse tree + */ + void exitReindex_target_type(PostgreSqlParser.Reindex_target_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reindex_target_multitable}. + * @param ctx the parse tree + */ + void enterReindex_target_multitable(PostgreSqlParser.Reindex_target_multitableContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reindex_target_multitable}. + * @param ctx the parse tree + */ + void exitReindex_target_multitable(PostgreSqlParser.Reindex_target_multitableContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reindex_option_list}. + * @param ctx the parse tree + */ + void enterReindex_option_list(PostgreSqlParser.Reindex_option_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reindex_option_list}. + * @param ctx the parse tree + */ + void exitReindex_option_list(PostgreSqlParser.Reindex_option_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reindex_option_elem}. + * @param ctx the parse tree + */ + void enterReindex_option_elem(PostgreSqlParser.Reindex_option_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reindex_option_elem}. + * @param ctx the parse tree + */ + void exitReindex_option_elem(PostgreSqlParser.Reindex_option_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#altertblspcstmt}. + * @param ctx the parse tree + */ + void enterAltertblspcstmt(PostgreSqlParser.AltertblspcstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#altertblspcstmt}. + * @param ctx the parse tree + */ + void exitAltertblspcstmt(PostgreSqlParser.AltertblspcstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#renamestmt}. + * @param ctx the parse tree + */ + void enterRenamestmt(PostgreSqlParser.RenamestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#renamestmt}. + * @param ctx the parse tree + */ + void exitRenamestmt(PostgreSqlParser.RenamestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_column}. + * @param ctx the parse tree + */ + void enterOpt_column(PostgreSqlParser.Opt_columnContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_column}. + * @param ctx the parse tree + */ + void exitOpt_column(PostgreSqlParser.Opt_columnContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_set_data}. + * @param ctx the parse tree + */ + void enterOpt_set_data(PostgreSqlParser.Opt_set_dataContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_set_data}. + * @param ctx the parse tree + */ + void exitOpt_set_data(PostgreSqlParser.Opt_set_dataContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterobjectdependsstmt}. + * @param ctx the parse tree + */ + void enterAlterobjectdependsstmt(PostgreSqlParser.AlterobjectdependsstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterobjectdependsstmt}. + * @param ctx the parse tree + */ + void exitAlterobjectdependsstmt(PostgreSqlParser.AlterobjectdependsstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_no}. + * @param ctx the parse tree + */ + void enterOpt_no(PostgreSqlParser.Opt_noContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_no}. + * @param ctx the parse tree + */ + void exitOpt_no(PostgreSqlParser.Opt_noContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterobjectschemastmt}. + * @param ctx the parse tree + */ + void enterAlterobjectschemastmt(PostgreSqlParser.AlterobjectschemastmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterobjectschemastmt}. + * @param ctx the parse tree + */ + void exitAlterobjectschemastmt(PostgreSqlParser.AlterobjectschemastmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alteroperatorstmt}. + * @param ctx the parse tree + */ + void enterAlteroperatorstmt(PostgreSqlParser.AlteroperatorstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alteroperatorstmt}. + * @param ctx the parse tree + */ + void exitAlteroperatorstmt(PostgreSqlParser.AlteroperatorstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#operator_def_list}. + * @param ctx the parse tree + */ + void enterOperator_def_list(PostgreSqlParser.Operator_def_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#operator_def_list}. + * @param ctx the parse tree + */ + void exitOperator_def_list(PostgreSqlParser.Operator_def_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#operator_def_elem}. + * @param ctx the parse tree + */ + void enterOperator_def_elem(PostgreSqlParser.Operator_def_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#operator_def_elem}. + * @param ctx the parse tree + */ + void exitOperator_def_elem(PostgreSqlParser.Operator_def_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#operator_def_arg}. + * @param ctx the parse tree + */ + void enterOperator_def_arg(PostgreSqlParser.Operator_def_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#operator_def_arg}. + * @param ctx the parse tree + */ + void exitOperator_def_arg(PostgreSqlParser.Operator_def_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#altertypestmt}. + * @param ctx the parse tree + */ + void enterAltertypestmt(PostgreSqlParser.AltertypestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#altertypestmt}. + * @param ctx the parse tree + */ + void exitAltertypestmt(PostgreSqlParser.AltertypestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterownerstmt}. + * @param ctx the parse tree + */ + void enterAlterownerstmt(PostgreSqlParser.AlterownerstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterownerstmt}. + * @param ctx the parse tree + */ + void exitAlterownerstmt(PostgreSqlParser.AlterownerstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createpublicationstmt}. + * @param ctx the parse tree + */ + void enterCreatepublicationstmt(PostgreSqlParser.CreatepublicationstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createpublicationstmt}. + * @param ctx the parse tree + */ + void exitCreatepublicationstmt(PostgreSqlParser.CreatepublicationstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_publication_for_tables}. + * @param ctx the parse tree + */ + void enterOpt_publication_for_tables(PostgreSqlParser.Opt_publication_for_tablesContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_publication_for_tables}. + * @param ctx the parse tree + */ + void exitOpt_publication_for_tables(PostgreSqlParser.Opt_publication_for_tablesContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#publication_for_tables}. + * @param ctx the parse tree + */ + void enterPublication_for_tables(PostgreSqlParser.Publication_for_tablesContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#publication_for_tables}. + * @param ctx the parse tree + */ + void exitPublication_for_tables(PostgreSqlParser.Publication_for_tablesContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alterpublicationstmt}. + * @param ctx the parse tree + */ + void enterAlterpublicationstmt(PostgreSqlParser.AlterpublicationstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alterpublicationstmt}. + * @param ctx the parse tree + */ + void exitAlterpublicationstmt(PostgreSqlParser.AlterpublicationstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#createsubscriptionstmt}. + * @param ctx the parse tree + */ + void enterCreatesubscriptionstmt(PostgreSqlParser.CreatesubscriptionstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#createsubscriptionstmt}. + * @param ctx the parse tree + */ + void exitCreatesubscriptionstmt(PostgreSqlParser.CreatesubscriptionstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#publication_name_list}. + * @param ctx the parse tree + */ + void enterPublication_name_list(PostgreSqlParser.Publication_name_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#publication_name_list}. + * @param ctx the parse tree + */ + void exitPublication_name_list(PostgreSqlParser.Publication_name_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#publication_name_item}. + * @param ctx the parse tree + */ + void enterPublication_name_item(PostgreSqlParser.Publication_name_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#publication_name_item}. + * @param ctx the parse tree + */ + void exitPublication_name_item(PostgreSqlParser.Publication_name_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#altersubscriptionstmt}. + * @param ctx the parse tree + */ + void enterAltersubscriptionstmt(PostgreSqlParser.AltersubscriptionstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#altersubscriptionstmt}. + * @param ctx the parse tree + */ + void exitAltersubscriptionstmt(PostgreSqlParser.AltersubscriptionstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#dropsubscriptionstmt}. + * @param ctx the parse tree + */ + void enterDropsubscriptionstmt(PostgreSqlParser.DropsubscriptionstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#dropsubscriptionstmt}. + * @param ctx the parse tree + */ + void exitDropsubscriptionstmt(PostgreSqlParser.DropsubscriptionstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rulestmt}. + * @param ctx the parse tree + */ + void enterRulestmt(PostgreSqlParser.RulestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rulestmt}. + * @param ctx the parse tree + */ + void exitRulestmt(PostgreSqlParser.RulestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#ruleactionlist}. + * @param ctx the parse tree + */ + void enterRuleactionlist(PostgreSqlParser.RuleactionlistContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#ruleactionlist}. + * @param ctx the parse tree + */ + void exitRuleactionlist(PostgreSqlParser.RuleactionlistContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#ruleactionmulti}. + * @param ctx the parse tree + */ + void enterRuleactionmulti(PostgreSqlParser.RuleactionmultiContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#ruleactionmulti}. + * @param ctx the parse tree + */ + void exitRuleactionmulti(PostgreSqlParser.RuleactionmultiContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#ruleactionstmt}. + * @param ctx the parse tree + */ + void enterRuleactionstmt(PostgreSqlParser.RuleactionstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#ruleactionstmt}. + * @param ctx the parse tree + */ + void exitRuleactionstmt(PostgreSqlParser.RuleactionstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#ruleactionstmtOrEmpty}. + * @param ctx the parse tree + */ + void enterRuleactionstmtOrEmpty(PostgreSqlParser.RuleactionstmtOrEmptyContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#ruleactionstmtOrEmpty}. + * @param ctx the parse tree + */ + void exitRuleactionstmtOrEmpty(PostgreSqlParser.RuleactionstmtOrEmptyContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#event}. + * @param ctx the parse tree + */ + void enterEvent(PostgreSqlParser.EventContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#event}. + * @param ctx the parse tree + */ + void exitEvent(PostgreSqlParser.EventContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_instead}. + * @param ctx the parse tree + */ + void enterOpt_instead(PostgreSqlParser.Opt_insteadContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_instead}. + * @param ctx the parse tree + */ + void exitOpt_instead(PostgreSqlParser.Opt_insteadContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#notifystmt}. + * @param ctx the parse tree + */ + void enterNotifystmt(PostgreSqlParser.NotifystmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#notifystmt}. + * @param ctx the parse tree + */ + void exitNotifystmt(PostgreSqlParser.NotifystmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#notify_payload}. + * @param ctx the parse tree + */ + void enterNotify_payload(PostgreSqlParser.Notify_payloadContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#notify_payload}. + * @param ctx the parse tree + */ + void exitNotify_payload(PostgreSqlParser.Notify_payloadContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#listenstmt}. + * @param ctx the parse tree + */ + void enterListenstmt(PostgreSqlParser.ListenstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#listenstmt}. + * @param ctx the parse tree + */ + void exitListenstmt(PostgreSqlParser.ListenstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#unlistenstmt}. + * @param ctx the parse tree + */ + void enterUnlistenstmt(PostgreSqlParser.UnlistenstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#unlistenstmt}. + * @param ctx the parse tree + */ + void exitUnlistenstmt(PostgreSqlParser.UnlistenstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transactionstmt}. + * @param ctx the parse tree + */ + void enterTransactionstmt(PostgreSqlParser.TransactionstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transactionstmt}. + * @param ctx the parse tree + */ + void exitTransactionstmt(PostgreSqlParser.TransactionstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_transaction}. + * @param ctx the parse tree + */ + void enterOpt_transaction(PostgreSqlParser.Opt_transactionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_transaction}. + * @param ctx the parse tree + */ + void exitOpt_transaction(PostgreSqlParser.Opt_transactionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transaction_mode_item}. + * @param ctx the parse tree + */ + void enterTransaction_mode_item(PostgreSqlParser.Transaction_mode_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transaction_mode_item}. + * @param ctx the parse tree + */ + void exitTransaction_mode_item(PostgreSqlParser.Transaction_mode_itemContext ctx); /** * Enter a parse tree produced by {@link PostgreSqlParser#transaction_mode_list}. * @param ctx the parse tree @@ -1828,315 +3980,1085 @@ public interface PostgreSqlParserListener extends ParseTreeListener { */ void exitTransaction_mode_list(PostgreSqlParser.Transaction_mode_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#set_transaction_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#transaction_mode_list_or_empty}. * @param ctx the parse tree */ - void enterSet_transaction_stmt(PostgreSqlParser.Set_transaction_stmtContext ctx); + void enterTransaction_mode_list_or_empty(PostgreSqlParser.Transaction_mode_list_or_emptyContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#set_transaction_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#transaction_mode_list_or_empty}. * @param ctx the parse tree */ - void exitSet_transaction_stmt(PostgreSqlParser.Set_transaction_stmtContext ctx); + void exitTransaction_mode_list_or_empty(PostgreSqlParser.Transaction_mode_list_or_emptyContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#show_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_transaction_chain}. * @param ctx the parse tree */ - void enterShow_stmt(PostgreSqlParser.Show_stmtContext ctx); + void enterOpt_transaction_chain(PostgreSqlParser.Opt_transaction_chainContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#show_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_transaction_chain}. * @param ctx the parse tree */ - void exitShow_stmt(PostgreSqlParser.Show_stmtContext ctx); + void exitOpt_transaction_chain(PostgreSqlParser.Opt_transaction_chainContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#truncate_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#viewstmt}. * @param ctx the parse tree */ - void enterTruncate_stmt(PostgreSqlParser.Truncate_stmtContext ctx); + void enterViewstmt(PostgreSqlParser.ViewstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#truncate_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#viewstmt}. * @param ctx the parse tree */ - void exitTruncate_stmt(PostgreSqlParser.Truncate_stmtContext ctx); + void exitViewstmt(PostgreSqlParser.ViewstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#unlisten_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_check_option}. * @param ctx the parse tree */ - void enterUnlisten_stmt(PostgreSqlParser.Unlisten_stmtContext ctx); + void enterOpt_check_option(PostgreSqlParser.Opt_check_optionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#unlisten_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_check_option}. * @param ctx the parse tree */ - void exitUnlisten_stmt(PostgreSqlParser.Unlisten_stmtContext ctx); + void exitOpt_check_option(PostgreSqlParser.Opt_check_optionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#update_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#loadstmt}. * @param ctx the parse tree */ - void enterUpdate_stmt(PostgreSqlParser.Update_stmtContext ctx); + void enterLoadstmt(PostgreSqlParser.LoadstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#update_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#loadstmt}. * @param ctx the parse tree */ - void exitUpdate_stmt(PostgreSqlParser.Update_stmtContext ctx); + void exitLoadstmt(PostgreSqlParser.LoadstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#vacuum_opt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createdbstmt}. * @param ctx the parse tree */ - void enterVacuum_opt(PostgreSqlParser.Vacuum_optContext ctx); + void enterCreatedbstmt(PostgreSqlParser.CreatedbstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#vacuum_opt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createdbstmt}. * @param ctx the parse tree */ - void exitVacuum_opt(PostgreSqlParser.Vacuum_optContext ctx); + void exitCreatedbstmt(PostgreSqlParser.CreatedbstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#vacuum_opt_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#createdb_opt_list}. * @param ctx the parse tree */ - void enterVacuum_opt_list(PostgreSqlParser.Vacuum_opt_listContext ctx); + void enterCreatedb_opt_list(PostgreSqlParser.Createdb_opt_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#vacuum_opt_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#createdb_opt_list}. * @param ctx the parse tree */ - void exitVacuum_opt_list(PostgreSqlParser.Vacuum_opt_listContext ctx); + void exitCreatedb_opt_list(PostgreSqlParser.Createdb_opt_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#vacuum_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createdb_opt_items}. * @param ctx the parse tree */ - void enterVacuum_stmt(PostgreSqlParser.Vacuum_stmtContext ctx); + void enterCreatedb_opt_items(PostgreSqlParser.Createdb_opt_itemsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#vacuum_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createdb_opt_items}. * @param ctx the parse tree */ - void exitVacuum_stmt(PostgreSqlParser.Vacuum_stmtContext ctx); + void exitCreatedb_opt_items(PostgreSqlParser.Createdb_opt_itemsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#values_stmt}. + * Enter a parse tree produced by {@link PostgreSqlParser#createdb_opt_item}. * @param ctx the parse tree */ - void enterValues_stmt(PostgreSqlParser.Values_stmtContext ctx); + void enterCreatedb_opt_item(PostgreSqlParser.Createdb_opt_itemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#values_stmt}. + * Exit a parse tree produced by {@link PostgreSqlParser#createdb_opt_item}. * @param ctx the parse tree */ - void exitValues_stmt(PostgreSqlParser.Values_stmtContext ctx); + void exitCreatedb_opt_item(PostgreSqlParser.Createdb_opt_itemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#selector_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#createdb_opt_name}. * @param ctx the parse tree */ - void enterSelector_clause(PostgreSqlParser.Selector_clauseContext ctx); + void enterCreatedb_opt_name(PostgreSqlParser.Createdb_opt_nameContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#selector_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#createdb_opt_name}. * @param ctx the parse tree */ - void exitSelector_clause(PostgreSqlParser.Selector_clauseContext ctx); + void exitCreatedb_opt_name(PostgreSqlParser.Createdb_opt_nameContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#from_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_equal}. * @param ctx the parse tree */ - void enterFrom_clause(PostgreSqlParser.From_clauseContext ctx); + void enterOpt_equal(PostgreSqlParser.Opt_equalContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#from_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_equal}. * @param ctx the parse tree */ - void exitFrom_clause(PostgreSqlParser.From_clauseContext ctx); + void exitOpt_equal(PostgreSqlParser.Opt_equalContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#where_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterdatabasestmt}. * @param ctx the parse tree */ - void enterWhere_clause(PostgreSqlParser.Where_clauseContext ctx); + void enterAlterdatabasestmt(PostgreSqlParser.AlterdatabasestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#where_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterdatabasestmt}. * @param ctx the parse tree */ - void exitWhere_clause(PostgreSqlParser.Where_clauseContext ctx); + void exitAlterdatabasestmt(PostgreSqlParser.AlterdatabasestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#group_by_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterdatabasesetstmt}. * @param ctx the parse tree */ - void enterGroup_by_clause(PostgreSqlParser.Group_by_clauseContext ctx); + void enterAlterdatabasesetstmt(PostgreSqlParser.AlterdatabasesetstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#group_by_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterdatabasesetstmt}. * @param ctx the parse tree */ - void exitGroup_by_clause(PostgreSqlParser.Group_by_clauseContext ctx); + void exitAlterdatabasesetstmt(PostgreSqlParser.AlterdatabasesetstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#grouping_elem}. + * Enter a parse tree produced by {@link PostgreSqlParser#dropdbstmt}. * @param ctx the parse tree */ - void enterGrouping_elem(PostgreSqlParser.Grouping_elemContext ctx); + void enterDropdbstmt(PostgreSqlParser.DropdbstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#grouping_elem}. + * Exit a parse tree produced by {@link PostgreSqlParser#dropdbstmt}. * @param ctx the parse tree */ - void exitGrouping_elem(PostgreSqlParser.Grouping_elemContext ctx); + void exitDropdbstmt(PostgreSqlParser.DropdbstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#grouping_elem_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#drop_option_list}. * @param ctx the parse tree */ - void enterGrouping_elem_list(PostgreSqlParser.Grouping_elem_listContext ctx); + void enterDrop_option_list(PostgreSqlParser.Drop_option_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#grouping_elem_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#drop_option_list}. * @param ctx the parse tree */ - void exitGrouping_elem_list(PostgreSqlParser.Grouping_elem_listContext ctx); + void exitDrop_option_list(PostgreSqlParser.Drop_option_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#having_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#drop_option}. * @param ctx the parse tree */ - void enterHaving_clause(PostgreSqlParser.Having_clauseContext ctx); + void enterDrop_option(PostgreSqlParser.Drop_optionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#having_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#drop_option}. * @param ctx the parse tree */ - void exitHaving_clause(PostgreSqlParser.Having_clauseContext ctx); + void exitDrop_option(PostgreSqlParser.Drop_optionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#column_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#altercollationstmt}. * @param ctx the parse tree */ - void enterColumn_list(PostgreSqlParser.Column_listContext ctx); + void enterAltercollationstmt(PostgreSqlParser.AltercollationstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#column_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#altercollationstmt}. * @param ctx the parse tree */ - void exitColumn_list(PostgreSqlParser.Column_listContext ctx); + void exitAltercollationstmt(PostgreSqlParser.AltercollationstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#explain_parameter}. + * Enter a parse tree produced by {@link PostgreSqlParser#altersystemstmt}. * @param ctx the parse tree */ - void enterExplain_parameter(PostgreSqlParser.Explain_parameterContext ctx); + void enterAltersystemstmt(PostgreSqlParser.AltersystemstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#explain_parameter}. + * Exit a parse tree produced by {@link PostgreSqlParser#altersystemstmt}. * @param ctx the parse tree */ - void exitExplain_parameter(PostgreSqlParser.Explain_parameterContext ctx); + void exitAltersystemstmt(PostgreSqlParser.AltersystemstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#frame}. + * Enter a parse tree produced by {@link PostgreSqlParser#createdomainstmt}. * @param ctx the parse tree */ - void enterFrame(PostgreSqlParser.FrameContext ctx); + void enterCreatedomainstmt(PostgreSqlParser.CreatedomainstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#frame}. + * Exit a parse tree produced by {@link PostgreSqlParser#createdomainstmt}. * @param ctx the parse tree */ - void exitFrame(PostgreSqlParser.FrameContext ctx); + void exitCreatedomainstmt(PostgreSqlParser.CreatedomainstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#frame_start}. + * Enter a parse tree produced by {@link PostgreSqlParser#alterdomainstmt}. * @param ctx the parse tree */ - void enterFrame_start(PostgreSqlParser.Frame_startContext ctx); + void enterAlterdomainstmt(PostgreSqlParser.AlterdomainstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#frame_start}. + * Exit a parse tree produced by {@link PostgreSqlParser#alterdomainstmt}. * @param ctx the parse tree */ - void exitFrame_start(PostgreSqlParser.Frame_startContext ctx); + void exitAlterdomainstmt(PostgreSqlParser.AlterdomainstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#frame_end}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_as}. * @param ctx the parse tree */ - void enterFrame_end(PostgreSqlParser.Frame_endContext ctx); + void enterOpt_as(PostgreSqlParser.Opt_asContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#frame_end}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_as}. * @param ctx the parse tree */ - void exitFrame_end(PostgreSqlParser.Frame_endContext ctx); + void exitOpt_as(PostgreSqlParser.Opt_asContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#frame_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#altertsdictionarystmt}. * @param ctx the parse tree */ - void enterFrame_clause(PostgreSqlParser.Frame_clauseContext ctx); + void enterAltertsdictionarystmt(PostgreSqlParser.AltertsdictionarystmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#frame_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#altertsdictionarystmt}. * @param ctx the parse tree */ - void exitFrame_clause(PostgreSqlParser.Frame_clauseContext ctx); + void exitAltertsdictionarystmt(PostgreSqlParser.AltertsdictionarystmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#window_definition_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#altertsconfigurationstmt}. * @param ctx the parse tree */ - void enterWindow_definition_list(PostgreSqlParser.Window_definition_listContext ctx); + void enterAltertsconfigurationstmt(PostgreSqlParser.AltertsconfigurationstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#window_definition_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#altertsconfigurationstmt}. * @param ctx the parse tree */ - void exitWindow_definition_list(PostgreSqlParser.Window_definition_listContext ctx); + void exitAltertsconfigurationstmt(PostgreSqlParser.AltertsconfigurationstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#window_definition}. + * Enter a parse tree produced by {@link PostgreSqlParser#any_with}. * @param ctx the parse tree */ - void enterWindow_definition(PostgreSqlParser.Window_definitionContext ctx); + void enterAny_with(PostgreSqlParser.Any_withContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#window_definition}. + * Exit a parse tree produced by {@link PostgreSqlParser#any_with}. * @param ctx the parse tree */ - void exitWindow_definition(PostgreSqlParser.Window_definitionContext ctx); + void exitAny_with(PostgreSqlParser.Any_withContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#window_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#createconversionstmt}. * @param ctx the parse tree */ - void enterWindow_clause(PostgreSqlParser.Window_clauseContext ctx); + void enterCreateconversionstmt(PostgreSqlParser.CreateconversionstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#window_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#createconversionstmt}. * @param ctx the parse tree */ - void exitWindow_clause(PostgreSqlParser.Window_clauseContext ctx); + void exitCreateconversionstmt(PostgreSqlParser.CreateconversionstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#window_specification}. + * Enter a parse tree produced by {@link PostgreSqlParser#clusterstmt}. * @param ctx the parse tree */ - void enterWindow_specification(PostgreSqlParser.Window_specificationContext ctx); + void enterClusterstmt(PostgreSqlParser.ClusterstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#window_specification}. + * Exit a parse tree produced by {@link PostgreSqlParser#clusterstmt}. * @param ctx the parse tree */ - void exitWindow_specification(PostgreSqlParser.Window_specificationContext ctx); + void exitClusterstmt(PostgreSqlParser.ClusterstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#partition_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#cluster_index_specification}. * @param ctx the parse tree */ - void enterPartition_clause(PostgreSqlParser.Partition_clauseContext ctx); + void enterCluster_index_specification(PostgreSqlParser.Cluster_index_specificationContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#partition_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#cluster_index_specification}. * @param ctx the parse tree */ - void exitPartition_clause(PostgreSqlParser.Partition_clauseContext ctx); + void exitCluster_index_specification(PostgreSqlParser.Cluster_index_specificationContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#over_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#vacuumstmt}. * @param ctx the parse tree */ - void enterOver_clause(PostgreSqlParser.Over_clauseContext ctx); + void enterVacuumstmt(PostgreSqlParser.VacuumstmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#over_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#vacuumstmt}. * @param ctx the parse tree */ - void exitOver_clause(PostgreSqlParser.Over_clauseContext ctx); + void exitVacuumstmt(PostgreSqlParser.VacuumstmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#combine_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#analyzestmt}. * @param ctx the parse tree */ - void enterCombine_clause(PostgreSqlParser.Combine_clauseContext ctx); + void enterAnalyzestmt(PostgreSqlParser.AnalyzestmtContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#combine_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#analyzestmt}. * @param ctx the parse tree */ - void exitCombine_clause(PostgreSqlParser.Combine_clauseContext ctx); + void exitAnalyzestmt(PostgreSqlParser.AnalyzestmtContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#order_by_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#vac_analyze_option_list}. * @param ctx the parse tree */ - void enterOrder_by_clause(PostgreSqlParser.Order_by_clauseContext ctx); + void enterVac_analyze_option_list(PostgreSqlParser.Vac_analyze_option_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#order_by_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#vac_analyze_option_list}. * @param ctx the parse tree */ - void exitOrder_by_clause(PostgreSqlParser.Order_by_clauseContext ctx); + void exitVac_analyze_option_list(PostgreSqlParser.Vac_analyze_option_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#order_by_item}. + * Enter a parse tree produced by {@link PostgreSqlParser#analyze_keyword}. * @param ctx the parse tree */ - void enterOrder_by_item(PostgreSqlParser.Order_by_itemContext ctx); + void enterAnalyze_keyword(PostgreSqlParser.Analyze_keywordContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#order_by_item}. + * Exit a parse tree produced by {@link PostgreSqlParser#analyze_keyword}. * @param ctx the parse tree */ - void exitOrder_by_item(PostgreSqlParser.Order_by_itemContext ctx); + void exitAnalyze_keyword(PostgreSqlParser.Analyze_keywordContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#vac_analyze_option_elem}. + * @param ctx the parse tree + */ + void enterVac_analyze_option_elem(PostgreSqlParser.Vac_analyze_option_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#vac_analyze_option_elem}. + * @param ctx the parse tree + */ + void exitVac_analyze_option_elem(PostgreSqlParser.Vac_analyze_option_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#vac_analyze_option_name}. + * @param ctx the parse tree + */ + void enterVac_analyze_option_name(PostgreSqlParser.Vac_analyze_option_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#vac_analyze_option_name}. + * @param ctx the parse tree + */ + void exitVac_analyze_option_name(PostgreSqlParser.Vac_analyze_option_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#vac_analyze_option_arg}. + * @param ctx the parse tree + */ + void enterVac_analyze_option_arg(PostgreSqlParser.Vac_analyze_option_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#vac_analyze_option_arg}. + * @param ctx the parse tree + */ + void exitVac_analyze_option_arg(PostgreSqlParser.Vac_analyze_option_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_analyze}. + * @param ctx the parse tree + */ + void enterOpt_analyze(PostgreSqlParser.Opt_analyzeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_analyze}. + * @param ctx the parse tree + */ + void exitOpt_analyze(PostgreSqlParser.Opt_analyzeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_verbose}. + * @param ctx the parse tree + */ + void enterOpt_verbose(PostgreSqlParser.Opt_verboseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_verbose}. + * @param ctx the parse tree + */ + void exitOpt_verbose(PostgreSqlParser.Opt_verboseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_full}. + * @param ctx the parse tree + */ + void enterOpt_full(PostgreSqlParser.Opt_fullContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_full}. + * @param ctx the parse tree + */ + void exitOpt_full(PostgreSqlParser.Opt_fullContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_freeze}. + * @param ctx the parse tree + */ + void enterOpt_freeze(PostgreSqlParser.Opt_freezeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_freeze}. + * @param ctx the parse tree + */ + void exitOpt_freeze(PostgreSqlParser.Opt_freezeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_name_list}. + * @param ctx the parse tree + */ + void enterOpt_name_list(PostgreSqlParser.Opt_name_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_name_list}. + * @param ctx the parse tree + */ + void exitOpt_name_list(PostgreSqlParser.Opt_name_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#vacuum_relation}. + * @param ctx the parse tree + */ + void enterVacuum_relation(PostgreSqlParser.Vacuum_relationContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#vacuum_relation}. + * @param ctx the parse tree + */ + void exitVacuum_relation(PostgreSqlParser.Vacuum_relationContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#vacuum_relation_list}. + * @param ctx the parse tree + */ + void enterVacuum_relation_list(PostgreSqlParser.Vacuum_relation_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#vacuum_relation_list}. + * @param ctx the parse tree + */ + void exitVacuum_relation_list(PostgreSqlParser.Vacuum_relation_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_vacuum_relation_list}. + * @param ctx the parse tree + */ + void enterOpt_vacuum_relation_list(PostgreSqlParser.Opt_vacuum_relation_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_vacuum_relation_list}. + * @param ctx the parse tree + */ + void exitOpt_vacuum_relation_list(PostgreSqlParser.Opt_vacuum_relation_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explainstmt}. + * @param ctx the parse tree + */ + void enterExplainstmt(PostgreSqlParser.ExplainstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explainstmt}. + * @param ctx the parse tree + */ + void exitExplainstmt(PostgreSqlParser.ExplainstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explainablestmt}. + * @param ctx the parse tree + */ + void enterExplainablestmt(PostgreSqlParser.ExplainablestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explainablestmt}. + * @param ctx the parse tree + */ + void exitExplainablestmt(PostgreSqlParser.ExplainablestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explain_option_list}. + * @param ctx the parse tree + */ + void enterExplain_option_list(PostgreSqlParser.Explain_option_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explain_option_list}. + * @param ctx the parse tree + */ + void exitExplain_option_list(PostgreSqlParser.Explain_option_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explain_option_elem}. + * @param ctx the parse tree + */ + void enterExplain_option_elem(PostgreSqlParser.Explain_option_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explain_option_elem}. + * @param ctx the parse tree + */ + void exitExplain_option_elem(PostgreSqlParser.Explain_option_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explain_option_name}. + * @param ctx the parse tree + */ + void enterExplain_option_name(PostgreSqlParser.Explain_option_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explain_option_name}. + * @param ctx the parse tree + */ + void exitExplain_option_name(PostgreSqlParser.Explain_option_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explain_option_arg}. + * @param ctx the parse tree + */ + void enterExplain_option_arg(PostgreSqlParser.Explain_option_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explain_option_arg}. + * @param ctx the parse tree + */ + void exitExplain_option_arg(PostgreSqlParser.Explain_option_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#preparestmt}. + * @param ctx the parse tree + */ + void enterPreparestmt(PostgreSqlParser.PreparestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#preparestmt}. + * @param ctx the parse tree + */ + void exitPreparestmt(PostgreSqlParser.PreparestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#prep_type_clause}. + * @param ctx the parse tree + */ + void enterPrep_type_clause(PostgreSqlParser.Prep_type_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#prep_type_clause}. + * @param ctx the parse tree + */ + void exitPrep_type_clause(PostgreSqlParser.Prep_type_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#preparablestmt}. + * @param ctx the parse tree + */ + void enterPreparablestmt(PostgreSqlParser.PreparablestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#preparablestmt}. + * @param ctx the parse tree + */ + void exitPreparablestmt(PostgreSqlParser.PreparablestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#executestmt}. + * @param ctx the parse tree + */ + void enterExecutestmt(PostgreSqlParser.ExecutestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#executestmt}. + * @param ctx the parse tree + */ + void exitExecutestmt(PostgreSqlParser.ExecutestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#execute_param_clause}. + * @param ctx the parse tree + */ + void enterExecute_param_clause(PostgreSqlParser.Execute_param_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#execute_param_clause}. + * @param ctx the parse tree + */ + void exitExecute_param_clause(PostgreSqlParser.Execute_param_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#deallocatestmt}. + * @param ctx the parse tree + */ + void enterDeallocatestmt(PostgreSqlParser.DeallocatestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#deallocatestmt}. + * @param ctx the parse tree + */ + void exitDeallocatestmt(PostgreSqlParser.DeallocatestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#insertstmt}. + * @param ctx the parse tree + */ + void enterInsertstmt(PostgreSqlParser.InsertstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#insertstmt}. + * @param ctx the parse tree + */ + void exitInsertstmt(PostgreSqlParser.InsertstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#insert_target}. + * @param ctx the parse tree + */ + void enterInsert_target(PostgreSqlParser.Insert_targetContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#insert_target}. + * @param ctx the parse tree + */ + void exitInsert_target(PostgreSqlParser.Insert_targetContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#insert_rest}. + * @param ctx the parse tree + */ + void enterInsert_rest(PostgreSqlParser.Insert_restContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#insert_rest}. + * @param ctx the parse tree + */ + void exitInsert_rest(PostgreSqlParser.Insert_restContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#override_kind}. + * @param ctx the parse tree + */ + void enterOverride_kind(PostgreSqlParser.Override_kindContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#override_kind}. + * @param ctx the parse tree + */ + void exitOverride_kind(PostgreSqlParser.Override_kindContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#insert_column_list}. + * @param ctx the parse tree + */ + void enterInsert_column_list(PostgreSqlParser.Insert_column_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#insert_column_list}. + * @param ctx the parse tree + */ + void exitInsert_column_list(PostgreSqlParser.Insert_column_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#insert_column_item}. + * @param ctx the parse tree + */ + void enterInsert_column_item(PostgreSqlParser.Insert_column_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#insert_column_item}. + * @param ctx the parse tree + */ + void exitInsert_column_item(PostgreSqlParser.Insert_column_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_on_conflict}. + * @param ctx the parse tree + */ + void enterOpt_on_conflict(PostgreSqlParser.Opt_on_conflictContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_on_conflict}. + * @param ctx the parse tree + */ + void exitOpt_on_conflict(PostgreSqlParser.Opt_on_conflictContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_conf_expr}. + * @param ctx the parse tree + */ + void enterOpt_conf_expr(PostgreSqlParser.Opt_conf_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_conf_expr}. + * @param ctx the parse tree + */ + void exitOpt_conf_expr(PostgreSqlParser.Opt_conf_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#returning_clause}. + * @param ctx the parse tree + */ + void enterReturning_clause(PostgreSqlParser.Returning_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#returning_clause}. + * @param ctx the parse tree + */ + void exitReturning_clause(PostgreSqlParser.Returning_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#mergestmt}. + * @param ctx the parse tree + */ + void enterMergestmt(PostgreSqlParser.MergestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#mergestmt}. + * @param ctx the parse tree + */ + void exitMergestmt(PostgreSqlParser.MergestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#merge_insert_clause}. + * @param ctx the parse tree + */ + void enterMerge_insert_clause(PostgreSqlParser.Merge_insert_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#merge_insert_clause}. + * @param ctx the parse tree + */ + void exitMerge_insert_clause(PostgreSqlParser.Merge_insert_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#merge_update_clause}. + * @param ctx the parse tree + */ + void enterMerge_update_clause(PostgreSqlParser.Merge_update_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#merge_update_clause}. + * @param ctx the parse tree + */ + void exitMerge_update_clause(PostgreSqlParser.Merge_update_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#merge_delete_clause}. + * @param ctx the parse tree + */ + void enterMerge_delete_clause(PostgreSqlParser.Merge_delete_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#merge_delete_clause}. + * @param ctx the parse tree + */ + void exitMerge_delete_clause(PostgreSqlParser.Merge_delete_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#deletestmt}. + * @param ctx the parse tree + */ + void enterDeletestmt(PostgreSqlParser.DeletestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#deletestmt}. + * @param ctx the parse tree + */ + void exitDeletestmt(PostgreSqlParser.DeletestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#using_clause}. + * @param ctx the parse tree + */ + void enterUsing_clause(PostgreSqlParser.Using_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#using_clause}. + * @param ctx the parse tree + */ + void exitUsing_clause(PostgreSqlParser.Using_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#lockstmt}. + * @param ctx the parse tree + */ + void enterLockstmt(PostgreSqlParser.LockstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#lockstmt}. + * @param ctx the parse tree + */ + void exitLockstmt(PostgreSqlParser.LockstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_lock}. + * @param ctx the parse tree + */ + void enterOpt_lock(PostgreSqlParser.Opt_lockContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_lock}. + * @param ctx the parse tree + */ + void exitOpt_lock(PostgreSqlParser.Opt_lockContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#lock_type}. + * @param ctx the parse tree + */ + void enterLock_type(PostgreSqlParser.Lock_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#lock_type}. + * @param ctx the parse tree + */ + void exitLock_type(PostgreSqlParser.Lock_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_nowait}. + * @param ctx the parse tree + */ + void enterOpt_nowait(PostgreSqlParser.Opt_nowaitContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_nowait}. + * @param ctx the parse tree + */ + void exitOpt_nowait(PostgreSqlParser.Opt_nowaitContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_nowait_or_skip}. + * @param ctx the parse tree + */ + void enterOpt_nowait_or_skip(PostgreSqlParser.Opt_nowait_or_skipContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_nowait_or_skip}. + * @param ctx the parse tree + */ + void exitOpt_nowait_or_skip(PostgreSqlParser.Opt_nowait_or_skipContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#updatestmt}. + * @param ctx the parse tree + */ + void enterUpdatestmt(PostgreSqlParser.UpdatestmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#updatestmt}. + * @param ctx the parse tree + */ + void exitUpdatestmt(PostgreSqlParser.UpdatestmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_clause_list}. + * @param ctx the parse tree + */ + void enterSet_clause_list(PostgreSqlParser.Set_clause_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_clause_list}. + * @param ctx the parse tree + */ + void exitSet_clause_list(PostgreSqlParser.Set_clause_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_clause}. + * @param ctx the parse tree + */ + void enterSet_clause(PostgreSqlParser.Set_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_clause}. + * @param ctx the parse tree + */ + void exitSet_clause(PostgreSqlParser.Set_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_target}. + * @param ctx the parse tree + */ + void enterSet_target(PostgreSqlParser.Set_targetContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_target}. + * @param ctx the parse tree + */ + void exitSet_target(PostgreSqlParser.Set_targetContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_target_list}. + * @param ctx the parse tree + */ + void enterSet_target_list(PostgreSqlParser.Set_target_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_target_list}. + * @param ctx the parse tree + */ + void exitSet_target_list(PostgreSqlParser.Set_target_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#declarecursorstmt}. + * @param ctx the parse tree + */ + void enterDeclarecursorstmt(PostgreSqlParser.DeclarecursorstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#declarecursorstmt}. + * @param ctx the parse tree + */ + void exitDeclarecursorstmt(PostgreSqlParser.DeclarecursorstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#cursor_name}. + * @param ctx the parse tree + */ + void enterCursor_name(PostgreSqlParser.Cursor_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#cursor_name}. + * @param ctx the parse tree + */ + void exitCursor_name(PostgreSqlParser.Cursor_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#cursor_options}. + * @param ctx the parse tree + */ + void enterCursor_options(PostgreSqlParser.Cursor_optionsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#cursor_options}. + * @param ctx the parse tree + */ + void exitCursor_options(PostgreSqlParser.Cursor_optionsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_hold}. + * @param ctx the parse tree + */ + void enterOpt_hold(PostgreSqlParser.Opt_holdContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_hold}. + * @param ctx the parse tree + */ + void exitOpt_hold(PostgreSqlParser.Opt_holdContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#selectstmt}. + * @param ctx the parse tree + */ + void enterSelectstmt(PostgreSqlParser.SelectstmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#selectstmt}. + * @param ctx the parse tree + */ + void exitSelectstmt(PostgreSqlParser.SelectstmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#select_with_parens}. + * @param ctx the parse tree + */ + void enterSelect_with_parens(PostgreSqlParser.Select_with_parensContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#select_with_parens}. + * @param ctx the parse tree + */ + void exitSelect_with_parens(PostgreSqlParser.Select_with_parensContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#select_no_parens}. + * @param ctx the parse tree + */ + void enterSelect_no_parens(PostgreSqlParser.Select_no_parensContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#select_no_parens}. + * @param ctx the parse tree + */ + void exitSelect_no_parens(PostgreSqlParser.Select_no_parensContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#select_clause}. + * @param ctx the parse tree + */ + void enterSelect_clause(PostgreSqlParser.Select_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#select_clause}. + * @param ctx the parse tree + */ + void exitSelect_clause(PostgreSqlParser.Select_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#simple_select_intersect}. + * @param ctx the parse tree + */ + void enterSimple_select_intersect(PostgreSqlParser.Simple_select_intersectContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#simple_select_intersect}. + * @param ctx the parse tree + */ + void exitSimple_select_intersect(PostgreSqlParser.Simple_select_intersectContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#simple_select_pramary}. + * @param ctx the parse tree + */ + void enterSimple_select_pramary(PostgreSqlParser.Simple_select_pramaryContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#simple_select_pramary}. + * @param ctx the parse tree + */ + void exitSimple_select_pramary(PostgreSqlParser.Simple_select_pramaryContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#top_clause}. + * @param ctx the parse tree + */ + void enterTop_clause(PostgreSqlParser.Top_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#top_clause}. + * @param ctx the parse tree + */ + void exitTop_clause(PostgreSqlParser.Top_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#with_clause}. + * @param ctx the parse tree + */ + void enterWith_clause(PostgreSqlParser.With_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#with_clause}. + * @param ctx the parse tree + */ + void exitWith_clause(PostgreSqlParser.With_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#cte_list}. + * @param ctx the parse tree + */ + void enterCte_list(PostgreSqlParser.Cte_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#cte_list}. + * @param ctx the parse tree + */ + void exitCte_list(PostgreSqlParser.Cte_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#common_table_expr}. + * @param ctx the parse tree + */ + void enterCommon_table_expr(PostgreSqlParser.Common_table_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#common_table_expr}. + * @param ctx the parse tree + */ + void exitCommon_table_expr(PostgreSqlParser.Common_table_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_materialized}. + * @param ctx the parse tree + */ + void enterOpt_materialized(PostgreSqlParser.Opt_materializedContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_materialized}. + * @param ctx the parse tree + */ + void exitOpt_materialized(PostgreSqlParser.Opt_materializedContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_with_clause}. + * @param ctx the parse tree + */ + void enterOpt_with_clause(PostgreSqlParser.Opt_with_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_with_clause}. + * @param ctx the parse tree + */ + void exitOpt_with_clause(PostgreSqlParser.Opt_with_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#into_clause}. + * @param ctx the parse tree + */ + void enterInto_clause(PostgreSqlParser.Into_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#into_clause}. + * @param ctx the parse tree + */ + void exitInto_clause(PostgreSqlParser.Into_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_strict}. + * @param ctx the parse tree + */ + void enterOpt_strict(PostgreSqlParser.Opt_strictContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_strict}. + * @param ctx the parse tree + */ + void exitOpt_strict(PostgreSqlParser.Opt_strictContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opttempTableName}. + * @param ctx the parse tree + */ + void enterOpttempTableName(PostgreSqlParser.OpttempTableNameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opttempTableName}. + * @param ctx the parse tree + */ + void exitOpttempTableName(PostgreSqlParser.OpttempTableNameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_table}. + * @param ctx the parse tree + */ + void enterOpt_table(PostgreSqlParser.Opt_tableContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_table}. + * @param ctx the parse tree + */ + void exitOpt_table(PostgreSqlParser.Opt_tableContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#all_or_distinct}. + * @param ctx the parse tree + */ + void enterAll_or_distinct(PostgreSqlParser.All_or_distinctContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#all_or_distinct}. + * @param ctx the parse tree + */ + void exitAll_or_distinct(PostgreSqlParser.All_or_distinctContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#distinct_clause}. + * @param ctx the parse tree + */ + void enterDistinct_clause(PostgreSqlParser.Distinct_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#distinct_clause}. + * @param ctx the parse tree + */ + void exitDistinct_clause(PostgreSqlParser.Distinct_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_all_clause}. + * @param ctx the parse tree + */ + void enterOpt_all_clause(PostgreSqlParser.Opt_all_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_all_clause}. + * @param ctx the parse tree + */ + void exitOpt_all_clause(PostgreSqlParser.Opt_all_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_sort_clause}. + * @param ctx the parse tree + */ + void enterOpt_sort_clause(PostgreSqlParser.Opt_sort_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_sort_clause}. + * @param ctx the parse tree + */ + void exitOpt_sort_clause(PostgreSqlParser.Opt_sort_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#sort_clause}. + * @param ctx the parse tree + */ + void enterSort_clause(PostgreSqlParser.Sort_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#sort_clause}. + * @param ctx the parse tree + */ + void exitSort_clause(PostgreSqlParser.Sort_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#sortby_list}. + * @param ctx the parse tree + */ + void enterSortby_list(PostgreSqlParser.Sortby_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#sortby_list}. + * @param ctx the parse tree + */ + void exitSortby_list(PostgreSqlParser.Sortby_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#sortby}. + * @param ctx the parse tree + */ + void enterSortby(PostgreSqlParser.SortbyContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#sortby}. + * @param ctx the parse tree + */ + void exitSortby(PostgreSqlParser.SortbyContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#select_limit}. + * @param ctx the parse tree + */ + void enterSelect_limit(PostgreSqlParser.Select_limitContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#select_limit}. + * @param ctx the parse tree + */ + void exitSelect_limit(PostgreSqlParser.Select_limitContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_select_limit}. + * @param ctx the parse tree + */ + void enterOpt_select_limit(PostgreSqlParser.Opt_select_limitContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_select_limit}. + * @param ctx the parse tree + */ + void exitOpt_select_limit(PostgreSqlParser.Opt_select_limitContext ctx); /** * Enter a parse tree produced by {@link PostgreSqlParser#limit_clause}. * @param ctx the parse tree @@ -2158,355 +5080,295 @@ public interface PostgreSqlParserListener extends ParseTreeListener { */ void exitOffset_clause(PostgreSqlParser.Offset_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#fetch_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#select_limit_value}. * @param ctx the parse tree */ - void enterFetch_clause(PostgreSqlParser.Fetch_clauseContext ctx); + void enterSelect_limit_value(PostgreSqlParser.Select_limit_valueContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#fetch_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#select_limit_value}. * @param ctx the parse tree */ - void exitFetch_clause(PostgreSqlParser.Fetch_clauseContext ctx); + void exitSelect_limit_value(PostgreSqlParser.Select_limit_valueContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#for_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#select_offset_value}. * @param ctx the parse tree */ - void enterFor_clause(PostgreSqlParser.For_clauseContext ctx); + void enterSelect_offset_value(PostgreSqlParser.Select_offset_valueContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#for_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#select_offset_value}. * @param ctx the parse tree */ - void exitFor_clause(PostgreSqlParser.For_clauseContext ctx); + void exitSelect_offset_value(PostgreSqlParser.Select_offset_valueContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#updater_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#select_fetch_first_value}. * @param ctx the parse tree */ - void enterUpdater_clause(PostgreSqlParser.Updater_clauseContext ctx); + void enterSelect_fetch_first_value(PostgreSqlParser.Select_fetch_first_valueContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#updater_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#select_fetch_first_value}. * @param ctx the parse tree */ - void exitUpdater_clause(PostgreSqlParser.Updater_clauseContext ctx); + void exitSelect_fetch_first_value(PostgreSqlParser.Select_fetch_first_valueContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#updater_expr}. + * Enter a parse tree produced by {@link PostgreSqlParser#i_or_f_const}. * @param ctx the parse tree */ - void enterUpdater_expr(PostgreSqlParser.Updater_exprContext ctx); + void enterI_or_f_const(PostgreSqlParser.I_or_f_constContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#updater_expr}. + * Exit a parse tree produced by {@link PostgreSqlParser#i_or_f_const}. * @param ctx the parse tree */ - void exitUpdater_expr(PostgreSqlParser.Updater_exprContext ctx); + void exitI_or_f_const(PostgreSqlParser.I_or_f_constContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#returning_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#row_or_rows}. * @param ctx the parse tree */ - void enterReturning_clause(PostgreSqlParser.Returning_clauseContext ctx); + void enterRow_or_rows(PostgreSqlParser.Row_or_rowsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#returning_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#row_or_rows}. * @param ctx the parse tree */ - void exitReturning_clause(PostgreSqlParser.Returning_clauseContext ctx); + void exitRow_or_rows(PostgreSqlParser.Row_or_rowsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#expr}. + * Enter a parse tree produced by {@link PostgreSqlParser#first_or_next}. * @param ctx the parse tree */ - void enterExpr(PostgreSqlParser.ExprContext ctx); + void enterFirst_or_next(PostgreSqlParser.First_or_nextContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#expr}. + * Exit a parse tree produced by {@link PostgreSqlParser#first_or_next}. * @param ctx the parse tree */ - void exitExpr(PostgreSqlParser.ExprContext ctx); + void exitFirst_or_next(PostgreSqlParser.First_or_nextContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#parameter}. + * Enter a parse tree produced by {@link PostgreSqlParser#group_clause}. * @param ctx the parse tree */ - void enterParameter(PostgreSqlParser.ParameterContext ctx); + void enterGroup_clause(PostgreSqlParser.Group_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#parameter}. + * Exit a parse tree produced by {@link PostgreSqlParser#group_clause}. * @param ctx the parse tree */ - void exitParameter(PostgreSqlParser.ParameterContext ctx); + void exitGroup_clause(PostgreSqlParser.Group_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#parameterOrIntegerLiteral}. + * Enter a parse tree produced by {@link PostgreSqlParser#group_by_list}. * @param ctx the parse tree */ - void enterParameterOrIntegerLiteral(PostgreSqlParser.ParameterOrIntegerLiteralContext ctx); + void enterGroup_by_list(PostgreSqlParser.Group_by_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#parameterOrIntegerLiteral}. + * Exit a parse tree produced by {@link PostgreSqlParser#group_by_list}. * @param ctx the parse tree */ - void exitParameterOrIntegerLiteral(PostgreSqlParser.ParameterOrIntegerLiteralContext ctx); + void exitGroup_by_list(PostgreSqlParser.Group_by_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#parameterOrNumericLiteral}. + * Enter a parse tree produced by {@link PostgreSqlParser#group_by_item}. * @param ctx the parse tree */ - void enterParameterOrNumericLiteral(PostgreSqlParser.ParameterOrNumericLiteralContext ctx); + void enterGroup_by_item(PostgreSqlParser.Group_by_itemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#parameterOrNumericLiteral}. + * Exit a parse tree produced by {@link PostgreSqlParser#group_by_item}. * @param ctx the parse tree */ - void exitParameterOrNumericLiteral(PostgreSqlParser.ParameterOrNumericLiteralContext ctx); + void exitGroup_by_item(PostgreSqlParser.Group_by_itemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#bool_expr}. + * Enter a parse tree produced by {@link PostgreSqlParser#empty_grouping_set}. * @param ctx the parse tree */ - void enterBool_expr(PostgreSqlParser.Bool_exprContext ctx); + void enterEmpty_grouping_set(PostgreSqlParser.Empty_grouping_setContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#bool_expr}. + * Exit a parse tree produced by {@link PostgreSqlParser#empty_grouping_set}. * @param ctx the parse tree */ - void exitBool_expr(PostgreSqlParser.Bool_exprContext ctx); + void exitEmpty_grouping_set(PostgreSqlParser.Empty_grouping_setContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#case_expr}. + * Enter a parse tree produced by {@link PostgreSqlParser#rollup_clause}. * @param ctx the parse tree */ - void enterCase_expr(PostgreSqlParser.Case_exprContext ctx); + void enterRollup_clause(PostgreSqlParser.Rollup_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#case_expr}. + * Exit a parse tree produced by {@link PostgreSqlParser#rollup_clause}. * @param ctx the parse tree */ - void exitCase_expr(PostgreSqlParser.Case_exprContext ctx); + void exitRollup_clause(PostgreSqlParser.Rollup_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#expr_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#cube_clause}. * @param ctx the parse tree */ - void enterExpr_list(PostgreSqlParser.Expr_listContext ctx); + void enterCube_clause(PostgreSqlParser.Cube_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#expr_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#cube_clause}. * @param ctx the parse tree */ - void exitExpr_list(PostgreSqlParser.Expr_listContext ctx); + void exitCube_clause(PostgreSqlParser.Cube_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#expr_list_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#grouping_sets_clause}. * @param ctx the parse tree */ - void enterExpr_list_list(PostgreSqlParser.Expr_list_listContext ctx); + void enterGrouping_sets_clause(PostgreSqlParser.Grouping_sets_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#expr_list_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#grouping_sets_clause}. * @param ctx the parse tree */ - void exitExpr_list_list(PostgreSqlParser.Expr_list_listContext ctx); + void exitGrouping_sets_clause(PostgreSqlParser.Grouping_sets_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#func_sig_arg}. + * Enter a parse tree produced by {@link PostgreSqlParser#having_clause}. * @param ctx the parse tree */ - void enterFunc_sig_arg(PostgreSqlParser.Func_sig_argContext ctx); + void enterHaving_clause(PostgreSqlParser.Having_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#func_sig_arg}. + * Exit a parse tree produced by {@link PostgreSqlParser#having_clause}. * @param ctx the parse tree */ - void exitFunc_sig_arg(PostgreSqlParser.Func_sig_argContext ctx); + void exitHaving_clause(PostgreSqlParser.Having_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#func_sig_arg_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#for_locking_clause}. * @param ctx the parse tree */ - void enterFunc_sig_arg_list(PostgreSqlParser.Func_sig_arg_listContext ctx); + void enterFor_locking_clause(PostgreSqlParser.For_locking_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#func_sig_arg_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#for_locking_clause}. * @param ctx the parse tree */ - void exitFunc_sig_arg_list(PostgreSqlParser.Func_sig_arg_listContext ctx); + void exitFor_locking_clause(PostgreSqlParser.For_locking_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#func_sig}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_for_locking_clause}. * @param ctx the parse tree */ - void enterFunc_sig(PostgreSqlParser.Func_sigContext ctx); + void enterOpt_for_locking_clause(PostgreSqlParser.Opt_for_locking_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#func_sig}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_for_locking_clause}. * @param ctx the parse tree */ - void exitFunc_sig(PostgreSqlParser.Func_sigContext ctx); + void exitOpt_for_locking_clause(PostgreSqlParser.Opt_for_locking_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#func_sig_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#for_locking_items}. * @param ctx the parse tree */ - void enterFunc_sig_list(PostgreSqlParser.Func_sig_listContext ctx); + void enterFor_locking_items(PostgreSqlParser.For_locking_itemsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#func_sig_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#for_locking_items}. * @param ctx the parse tree */ - void exitFunc_sig_list(PostgreSqlParser.Func_sig_listContext ctx); + void exitFor_locking_items(PostgreSqlParser.For_locking_itemsContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#type_name}. + * Enter a parse tree produced by {@link PostgreSqlParser#for_locking_item}. * @param ctx the parse tree */ - void enterType_name(PostgreSqlParser.Type_nameContext ctx); + void enterFor_locking_item(PostgreSqlParser.For_locking_itemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#type_name}. + * Exit a parse tree produced by {@link PostgreSqlParser#for_locking_item}. * @param ctx the parse tree */ - void exitType_name(PostgreSqlParser.Type_nameContext ctx); + void exitFor_locking_item(PostgreSqlParser.For_locking_itemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#timezone}. + * Enter a parse tree produced by {@link PostgreSqlParser#for_locking_strength}. * @param ctx the parse tree */ - void enterTimezone(PostgreSqlParser.TimezoneContext ctx); + void enterFor_locking_strength(PostgreSqlParser.For_locking_strengthContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#timezone}. + * Exit a parse tree produced by {@link PostgreSqlParser#for_locking_strength}. * @param ctx the parse tree */ - void exitTimezone(PostgreSqlParser.TimezoneContext ctx); + void exitFor_locking_strength(PostgreSqlParser.For_locking_strengthContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#oper}. + * Enter a parse tree produced by {@link PostgreSqlParser#locked_rels_list}. * @param ctx the parse tree */ - void enterOper(PostgreSqlParser.OperContext ctx); + void enterLocked_rels_list(PostgreSqlParser.Locked_rels_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#oper}. + * Exit a parse tree produced by {@link PostgreSqlParser#locked_rels_list}. * @param ctx the parse tree */ - void exitOper(PostgreSqlParser.OperContext ctx); + void exitLocked_rels_list(PostgreSqlParser.Locked_rels_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#aggregate}. + * Enter a parse tree produced by {@link PostgreSqlParser#values_clause}. * @param ctx the parse tree */ - void enterAggregate(PostgreSqlParser.AggregateContext ctx); + void enterValues_clause(PostgreSqlParser.Values_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#aggregate}. + * Exit a parse tree produced by {@link PostgreSqlParser#values_clause}. * @param ctx the parse tree */ - void exitAggregate(PostgreSqlParser.AggregateContext ctx); + void exitValues_clause(PostgreSqlParser.Values_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#name_}. + * Enter a parse tree produced by {@link PostgreSqlParser#from_clause}. * @param ctx the parse tree */ - void enterName_(PostgreSqlParser.Name_Context ctx); + void enterFrom_clause(PostgreSqlParser.From_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#name_}. + * Exit a parse tree produced by {@link PostgreSqlParser#from_clause}. * @param ctx the parse tree */ - void exitName_(PostgreSqlParser.Name_Context ctx); + void exitFrom_clause(PostgreSqlParser.From_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#name_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#from_list}. * @param ctx the parse tree */ - void enterName_list(PostgreSqlParser.Name_listContext ctx); + void enterFrom_list(PostgreSqlParser.From_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#name_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#from_list}. * @param ctx the parse tree */ - void exitName_list(PostgreSqlParser.Name_listContext ctx); + void exitFrom_list(PostgreSqlParser.From_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#identifier_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#non_ansi_join}. * @param ctx the parse tree */ - void enterIdentifier_list(PostgreSqlParser.Identifier_listContext ctx); + void enterNon_ansi_join(PostgreSqlParser.Non_ansi_joinContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#identifier_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#non_ansi_join}. * @param ctx the parse tree */ - void exitIdentifier_list(PostgreSqlParser.Identifier_listContext ctx); + void exitNon_ansi_join(PostgreSqlParser.Non_ansi_joinContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#option_expr}. + * Enter a parse tree produced by {@link PostgreSqlParser#table_ref}. * @param ctx the parse tree */ - void enterOption_expr(PostgreSqlParser.Option_exprContext ctx); + void enterTable_ref(PostgreSqlParser.Table_refContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#option_expr}. + * Exit a parse tree produced by {@link PostgreSqlParser#table_ref}. * @param ctx the parse tree */ - void exitOption_expr(PostgreSqlParser.Option_exprContext ctx); + void exitTable_ref(PostgreSqlParser.Table_refContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#option_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#alias_clause}. * @param ctx the parse tree */ - void enterOption_list(PostgreSqlParser.Option_listContext ctx); + void enterAlias_clause(PostgreSqlParser.Alias_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#option_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#alias_clause}. * @param ctx the parse tree */ - void exitOption_list(PostgreSqlParser.Option_listContext ctx); + void exitAlias_clause(PostgreSqlParser.Alias_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#table_name_}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_alias_clause}. * @param ctx the parse tree */ - void enterTable_name_(PostgreSqlParser.Table_name_Context ctx); + void enterOpt_alias_clause(PostgreSqlParser.Opt_alias_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#table_name_}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_alias_clause}. * @param ctx the parse tree */ - void exitTable_name_(PostgreSqlParser.Table_name_Context ctx); + void exitOpt_alias_clause(PostgreSqlParser.Opt_alias_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#data_type}. + * Enter a parse tree produced by {@link PostgreSqlParser#table_alias_clause}. * @param ctx the parse tree */ - void enterData_type(PostgreSqlParser.Data_typeContext ctx); + void enterTable_alias_clause(PostgreSqlParser.Table_alias_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#data_type}. + * Exit a parse tree produced by {@link PostgreSqlParser#table_alias_clause}. * @param ctx the parse tree */ - void exitData_type(PostgreSqlParser.Data_typeContext ctx); + void exitTable_alias_clause(PostgreSqlParser.Table_alias_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#data_type_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#func_alias_clause}. * @param ctx the parse tree */ - void enterData_type_list(PostgreSqlParser.Data_type_listContext ctx); + void enterFunc_alias_clause(PostgreSqlParser.Func_alias_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#data_type_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#func_alias_clause}. * @param ctx the parse tree */ - void exitData_type_list(PostgreSqlParser.Data_type_listContext ctx); - /** - * Enter a parse tree produced by {@link PostgreSqlParser#index_method}. - * @param ctx the parse tree - */ - void enterIndex_method(PostgreSqlParser.Index_methodContext ctx); - /** - * Exit a parse tree produced by {@link PostgreSqlParser#index_method}. - * @param ctx the parse tree - */ - void exitIndex_method(PostgreSqlParser.Index_methodContext ctx); - /** - * Enter a parse tree produced by {@link PostgreSqlParser#func_name}. - * @param ctx the parse tree - */ - void enterFunc_name(PostgreSqlParser.Func_nameContext ctx); - /** - * Exit a parse tree produced by {@link PostgreSqlParser#func_name}. - * @param ctx the parse tree - */ - void exitFunc_name(PostgreSqlParser.Func_nameContext ctx); - /** - * Enter a parse tree produced by {@link PostgreSqlParser#func_call}. - * @param ctx the parse tree - */ - void enterFunc_call(PostgreSqlParser.Func_callContext ctx); - /** - * Exit a parse tree produced by {@link PostgreSqlParser#func_call}. - * @param ctx the parse tree - */ - void exitFunc_call(PostgreSqlParser.Func_callContext ctx); - /** - * Enter a parse tree produced by {@link PostgreSqlParser#array_cons_expr}. - * @param ctx the parse tree - */ - void enterArray_cons_expr(PostgreSqlParser.Array_cons_exprContext ctx); - /** - * Exit a parse tree produced by {@link PostgreSqlParser#array_cons_expr}. - * @param ctx the parse tree - */ - void exitArray_cons_expr(PostgreSqlParser.Array_cons_exprContext ctx); - /** - * Enter a parse tree produced by {@link PostgreSqlParser#from_item}. - * @param ctx the parse tree - */ - void enterFrom_item(PostgreSqlParser.From_itemContext ctx); - /** - * Exit a parse tree produced by {@link PostgreSqlParser#from_item}. - * @param ctx the parse tree - */ - void exitFrom_item(PostgreSqlParser.From_itemContext ctx); - /** - * Enter a parse tree produced by {@link PostgreSqlParser#with_column_alias}. - * @param ctx the parse tree - */ - void enterWith_column_alias(PostgreSqlParser.With_column_aliasContext ctx); - /** - * Exit a parse tree produced by {@link PostgreSqlParser#with_column_alias}. - * @param ctx the parse tree - */ - void exitWith_column_alias(PostgreSqlParser.With_column_aliasContext ctx); + void exitFunc_alias_clause(PostgreSqlParser.Func_alias_clauseContext ctx); /** * Enter a parse tree produced by {@link PostgreSqlParser#join_type}. * @param ctx the parse tree @@ -2518,135 +5380,1599 @@ public interface PostgreSqlParserListener extends ParseTreeListener { */ void exitJoin_type(PostgreSqlParser.Join_typeContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#join_clause}. + * Enter a parse tree produced by {@link PostgreSqlParser#join_qual}. * @param ctx the parse tree */ - void enterJoin_clause(PostgreSqlParser.Join_clauseContext ctx); + void enterJoin_qual(PostgreSqlParser.Join_qualContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#join_clause}. + * Exit a parse tree produced by {@link PostgreSqlParser#join_qual}. * @param ctx the parse tree */ - void exitJoin_clause(PostgreSqlParser.Join_clauseContext ctx); + void exitJoin_qual(PostgreSqlParser.Join_qualContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#predicate}. + * Enter a parse tree produced by {@link PostgreSqlParser#relation_expr}. * @param ctx the parse tree */ - void enterPredicate(PostgreSqlParser.PredicateContext ctx); + void enterRelation_expr(PostgreSqlParser.Relation_exprContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#predicate}. + * Exit a parse tree produced by {@link PostgreSqlParser#relation_expr}. * @param ctx the parse tree */ - void exitPredicate(PostgreSqlParser.PredicateContext ctx); + void exitRelation_expr(PostgreSqlParser.Relation_exprContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#aggregate_signature}. + * Enter a parse tree produced by {@link PostgreSqlParser#relation_expr_list}. * @param ctx the parse tree */ - void enterAggregate_signature(PostgreSqlParser.Aggregate_signatureContext ctx); + void enterRelation_expr_list(PostgreSqlParser.Relation_expr_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#aggregate_signature}. + * Exit a parse tree produced by {@link PostgreSqlParser#relation_expr_list}. * @param ctx the parse tree */ - void exitAggregate_signature(PostgreSqlParser.Aggregate_signatureContext ctx); + void exitRelation_expr_list(PostgreSqlParser.Relation_expr_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#column_constraint}. + * Enter a parse tree produced by {@link PostgreSqlParser#relation_expr_opt_alias}. * @param ctx the parse tree */ - void enterColumn_constraint(PostgreSqlParser.Column_constraintContext ctx); + void enterRelation_expr_opt_alias(PostgreSqlParser.Relation_expr_opt_aliasContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#column_constraint}. + * Exit a parse tree produced by {@link PostgreSqlParser#relation_expr_opt_alias}. * @param ctx the parse tree */ - void exitColumn_constraint(PostgreSqlParser.Column_constraintContext ctx); + void exitRelation_expr_opt_alias(PostgreSqlParser.Relation_expr_opt_aliasContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#column_constraints}. + * Enter a parse tree produced by {@link PostgreSqlParser#tablesample_clause}. * @param ctx the parse tree */ - void enterColumn_constraints(PostgreSqlParser.Column_constraintsContext ctx); + void enterTablesample_clause(PostgreSqlParser.Tablesample_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#column_constraints}. + * Exit a parse tree produced by {@link PostgreSqlParser#tablesample_clause}. * @param ctx the parse tree */ - void exitColumn_constraints(PostgreSqlParser.Column_constraintsContext ctx); + void exitTablesample_clause(PostgreSqlParser.Tablesample_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#index_parameters}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_repeatable_clause}. * @param ctx the parse tree */ - void enterIndex_parameters(PostgreSqlParser.Index_parametersContext ctx); + void enterOpt_repeatable_clause(PostgreSqlParser.Opt_repeatable_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#index_parameters}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_repeatable_clause}. * @param ctx the parse tree */ - void exitIndex_parameters(PostgreSqlParser.Index_parametersContext ctx); + void exitOpt_repeatable_clause(PostgreSqlParser.Opt_repeatable_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#exclude_element}. + * Enter a parse tree produced by {@link PostgreSqlParser#func_table}. * @param ctx the parse tree */ - void enterExclude_element(PostgreSqlParser.Exclude_elementContext ctx); + void enterFunc_table(PostgreSqlParser.Func_tableContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#exclude_element}. + * Exit a parse tree produced by {@link PostgreSqlParser#func_table}. * @param ctx the parse tree */ - void exitExclude_element(PostgreSqlParser.Exclude_elementContext ctx); + void exitFunc_table(PostgreSqlParser.Func_tableContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#table_constraint}. + * Enter a parse tree produced by {@link PostgreSqlParser#rowsfrom_item}. * @param ctx the parse tree */ - void enterTable_constraint(PostgreSqlParser.Table_constraintContext ctx); + void enterRowsfrom_item(PostgreSqlParser.Rowsfrom_itemContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#table_constraint}. + * Exit a parse tree produced by {@link PostgreSqlParser#rowsfrom_item}. * @param ctx the parse tree */ - void exitTable_constraint(PostgreSqlParser.Table_constraintContext ctx); + void exitRowsfrom_item(PostgreSqlParser.Rowsfrom_itemContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#role_name}. + * Enter a parse tree produced by {@link PostgreSqlParser#rowsfrom_list}. * @param ctx the parse tree */ - void enterRole_name(PostgreSqlParser.Role_nameContext ctx); + void enterRowsfrom_list(PostgreSqlParser.Rowsfrom_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#role_name}. + * Exit a parse tree produced by {@link PostgreSqlParser#rowsfrom_list}. * @param ctx the parse tree */ - void exitRole_name(PostgreSqlParser.Role_nameContext ctx); + void exitRowsfrom_list(PostgreSqlParser.Rowsfrom_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#role_name_list}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_col_def_list}. * @param ctx the parse tree */ - void enterRole_name_list(PostgreSqlParser.Role_name_listContext ctx); + void enterOpt_col_def_list(PostgreSqlParser.Opt_col_def_listContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#role_name_list}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_col_def_list}. * @param ctx the parse tree */ - void exitRole_name_list(PostgreSqlParser.Role_name_listContext ctx); + void exitOpt_col_def_list(PostgreSqlParser.Opt_col_def_listContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#param_value}. + * Enter a parse tree produced by {@link PostgreSqlParser#opt_ordinality}. * @param ctx the parse tree */ - void enterParam_value(PostgreSqlParser.Param_valueContext ctx); + void enterOpt_ordinality(PostgreSqlParser.Opt_ordinalityContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#param_value}. + * Exit a parse tree produced by {@link PostgreSqlParser#opt_ordinality}. * @param ctx the parse tree */ - void exitParam_value(PostgreSqlParser.Param_valueContext ctx); + void exitOpt_ordinality(PostgreSqlParser.Opt_ordinalityContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#reserved_keyword}. + * Enter a parse tree produced by {@link PostgreSqlParser#where_clause}. * @param ctx the parse tree */ - void enterReserved_keyword(PostgreSqlParser.Reserved_keywordContext ctx); + void enterWhere_clause(PostgreSqlParser.Where_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#reserved_keyword}. + * Exit a parse tree produced by {@link PostgreSqlParser#where_clause}. * @param ctx the parse tree */ - void exitReserved_keyword(PostgreSqlParser.Reserved_keywordContext ctx); + void exitWhere_clause(PostgreSqlParser.Where_clauseContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#non_reserved_keyword}. + * Enter a parse tree produced by {@link PostgreSqlParser#where_or_current_clause}. * @param ctx the parse tree */ - void enterNon_reserved_keyword(PostgreSqlParser.Non_reserved_keywordContext ctx); + void enterWhere_or_current_clause(PostgreSqlParser.Where_or_current_clauseContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#non_reserved_keyword}. + * Exit a parse tree produced by {@link PostgreSqlParser#where_or_current_clause}. * @param ctx the parse tree */ - void exitNon_reserved_keyword(PostgreSqlParser.Non_reserved_keywordContext ctx); + void exitWhere_or_current_clause(PostgreSqlParser.Where_or_current_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opttablefuncelementlist}. + * @param ctx the parse tree + */ + void enterOpttablefuncelementlist(PostgreSqlParser.OpttablefuncelementlistContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opttablefuncelementlist}. + * @param ctx the parse tree + */ + void exitOpttablefuncelementlist(PostgreSqlParser.OpttablefuncelementlistContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#tablefuncelementlist}. + * @param ctx the parse tree + */ + void enterTablefuncelementlist(PostgreSqlParser.TablefuncelementlistContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#tablefuncelementlist}. + * @param ctx the parse tree + */ + void exitTablefuncelementlist(PostgreSqlParser.TablefuncelementlistContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#tablefuncelement}. + * @param ctx the parse tree + */ + void enterTablefuncelement(PostgreSqlParser.TablefuncelementContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#tablefuncelement}. + * @param ctx the parse tree + */ + void exitTablefuncelement(PostgreSqlParser.TablefuncelementContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xmltable}. + * @param ctx the parse tree + */ + void enterXmltable(PostgreSqlParser.XmltableContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xmltable}. + * @param ctx the parse tree + */ + void exitXmltable(PostgreSqlParser.XmltableContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xmltable_column_list}. + * @param ctx the parse tree + */ + void enterXmltable_column_list(PostgreSqlParser.Xmltable_column_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xmltable_column_list}. + * @param ctx the parse tree + */ + void exitXmltable_column_list(PostgreSqlParser.Xmltable_column_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xmltable_column_el}. + * @param ctx the parse tree + */ + void enterXmltable_column_el(PostgreSqlParser.Xmltable_column_elContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xmltable_column_el}. + * @param ctx the parse tree + */ + void exitXmltable_column_el(PostgreSqlParser.Xmltable_column_elContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xmltable_column_option_list}. + * @param ctx the parse tree + */ + void enterXmltable_column_option_list(PostgreSqlParser.Xmltable_column_option_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xmltable_column_option_list}. + * @param ctx the parse tree + */ + void exitXmltable_column_option_list(PostgreSqlParser.Xmltable_column_option_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xmltable_column_option_el}. + * @param ctx the parse tree + */ + void enterXmltable_column_option_el(PostgreSqlParser.Xmltable_column_option_elContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xmltable_column_option_el}. + * @param ctx the parse tree + */ + void exitXmltable_column_option_el(PostgreSqlParser.Xmltable_column_option_elContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xml_namespace_list}. + * @param ctx the parse tree + */ + void enterXml_namespace_list(PostgreSqlParser.Xml_namespace_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xml_namespace_list}. + * @param ctx the parse tree + */ + void exitXml_namespace_list(PostgreSqlParser.Xml_namespace_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xml_namespace_el}. + * @param ctx the parse tree + */ + void enterXml_namespace_el(PostgreSqlParser.Xml_namespace_elContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xml_namespace_el}. + * @param ctx the parse tree + */ + void exitXml_namespace_el(PostgreSqlParser.Xml_namespace_elContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#typename}. + * @param ctx the parse tree + */ + void enterTypename(PostgreSqlParser.TypenameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#typename}. + * @param ctx the parse tree + */ + void exitTypename(PostgreSqlParser.TypenameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_array_bounds}. + * @param ctx the parse tree + */ + void enterOpt_array_bounds(PostgreSqlParser.Opt_array_boundsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_array_bounds}. + * @param ctx the parse tree + */ + void exitOpt_array_bounds(PostgreSqlParser.Opt_array_boundsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#simpletypename}. + * @param ctx the parse tree + */ + void enterSimpletypename(PostgreSqlParser.SimpletypenameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#simpletypename}. + * @param ctx the parse tree + */ + void exitSimpletypename(PostgreSqlParser.SimpletypenameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#consttypename}. + * @param ctx the parse tree + */ + void enterConsttypename(PostgreSqlParser.ConsttypenameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#consttypename}. + * @param ctx the parse tree + */ + void exitConsttypename(PostgreSqlParser.ConsttypenameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#generictype}. + * @param ctx the parse tree + */ + void enterGenerictype(PostgreSqlParser.GenerictypeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#generictype}. + * @param ctx the parse tree + */ + void exitGenerictype(PostgreSqlParser.GenerictypeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_type_modifiers}. + * @param ctx the parse tree + */ + void enterOpt_type_modifiers(PostgreSqlParser.Opt_type_modifiersContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_type_modifiers}. + * @param ctx the parse tree + */ + void exitOpt_type_modifiers(PostgreSqlParser.Opt_type_modifiersContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#numeric}. + * @param ctx the parse tree + */ + void enterNumeric(PostgreSqlParser.NumericContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#numeric}. + * @param ctx the parse tree + */ + void exitNumeric(PostgreSqlParser.NumericContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_float}. + * @param ctx the parse tree + */ + void enterOpt_float(PostgreSqlParser.Opt_floatContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_float}. + * @param ctx the parse tree + */ + void exitOpt_float(PostgreSqlParser.Opt_floatContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#bit}. + * @param ctx the parse tree + */ + void enterBit(PostgreSqlParser.BitContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#bit}. + * @param ctx the parse tree + */ + void exitBit(PostgreSqlParser.BitContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#constbit}. + * @param ctx the parse tree + */ + void enterConstbit(PostgreSqlParser.ConstbitContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#constbit}. + * @param ctx the parse tree + */ + void exitConstbit(PostgreSqlParser.ConstbitContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#bitwithlength}. + * @param ctx the parse tree + */ + void enterBitwithlength(PostgreSqlParser.BitwithlengthContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#bitwithlength}. + * @param ctx the parse tree + */ + void exitBitwithlength(PostgreSqlParser.BitwithlengthContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#bitwithoutlength}. + * @param ctx the parse tree + */ + void enterBitwithoutlength(PostgreSqlParser.BitwithoutlengthContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#bitwithoutlength}. + * @param ctx the parse tree + */ + void exitBitwithoutlength(PostgreSqlParser.BitwithoutlengthContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#character}. + * @param ctx the parse tree + */ + void enterCharacter(PostgreSqlParser.CharacterContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#character}. + * @param ctx the parse tree + */ + void exitCharacter(PostgreSqlParser.CharacterContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#constcharacter}. + * @param ctx the parse tree + */ + void enterConstcharacter(PostgreSqlParser.ConstcharacterContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#constcharacter}. + * @param ctx the parse tree + */ + void exitConstcharacter(PostgreSqlParser.ConstcharacterContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#character_c}. + * @param ctx the parse tree + */ + void enterCharacter_c(PostgreSqlParser.Character_cContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#character_c}. + * @param ctx the parse tree + */ + void exitCharacter_c(PostgreSqlParser.Character_cContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_varying}. + * @param ctx the parse tree + */ + void enterOpt_varying(PostgreSqlParser.Opt_varyingContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_varying}. + * @param ctx the parse tree + */ + void exitOpt_varying(PostgreSqlParser.Opt_varyingContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#constdatetime}. + * @param ctx the parse tree + */ + void enterConstdatetime(PostgreSqlParser.ConstdatetimeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#constdatetime}. + * @param ctx the parse tree + */ + void exitConstdatetime(PostgreSqlParser.ConstdatetimeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#constinterval}. + * @param ctx the parse tree + */ + void enterConstinterval(PostgreSqlParser.ConstintervalContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#constinterval}. + * @param ctx the parse tree + */ + void exitConstinterval(PostgreSqlParser.ConstintervalContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_timezone}. + * @param ctx the parse tree + */ + void enterOpt_timezone(PostgreSqlParser.Opt_timezoneContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_timezone}. + * @param ctx the parse tree + */ + void exitOpt_timezone(PostgreSqlParser.Opt_timezoneContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_interval}. + * @param ctx the parse tree + */ + void enterOpt_interval(PostgreSqlParser.Opt_intervalContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_interval}. + * @param ctx the parse tree + */ + void exitOpt_interval(PostgreSqlParser.Opt_intervalContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#interval_second}. + * @param ctx the parse tree + */ + void enterInterval_second(PostgreSqlParser.Interval_secondContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#interval_second}. + * @param ctx the parse tree + */ + void exitInterval_second(PostgreSqlParser.Interval_secondContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_escape}. + * @param ctx the parse tree + */ + void enterOpt_escape(PostgreSqlParser.Opt_escapeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_escape}. + * @param ctx the parse tree + */ + void exitOpt_escape(PostgreSqlParser.Opt_escapeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr}. + * @param ctx the parse tree + */ + void enterA_expr(PostgreSqlParser.A_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr}. + * @param ctx the parse tree + */ + void exitA_expr(PostgreSqlParser.A_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_qual}. + * @param ctx the parse tree + */ + void enterA_expr_qual(PostgreSqlParser.A_expr_qualContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_qual}. + * @param ctx the parse tree + */ + void exitA_expr_qual(PostgreSqlParser.A_expr_qualContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_lessless}. + * @param ctx the parse tree + */ + void enterA_expr_lessless(PostgreSqlParser.A_expr_lesslessContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_lessless}. + * @param ctx the parse tree + */ + void exitA_expr_lessless(PostgreSqlParser.A_expr_lesslessContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_or}. + * @param ctx the parse tree + */ + void enterA_expr_or(PostgreSqlParser.A_expr_orContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_or}. + * @param ctx the parse tree + */ + void exitA_expr_or(PostgreSqlParser.A_expr_orContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_and}. + * @param ctx the parse tree + */ + void enterA_expr_and(PostgreSqlParser.A_expr_andContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_and}. + * @param ctx the parse tree + */ + void exitA_expr_and(PostgreSqlParser.A_expr_andContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_between}. + * @param ctx the parse tree + */ + void enterA_expr_between(PostgreSqlParser.A_expr_betweenContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_between}. + * @param ctx the parse tree + */ + void exitA_expr_between(PostgreSqlParser.A_expr_betweenContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_in}. + * @param ctx the parse tree + */ + void enterA_expr_in(PostgreSqlParser.A_expr_inContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_in}. + * @param ctx the parse tree + */ + void exitA_expr_in(PostgreSqlParser.A_expr_inContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_unary_not}. + * @param ctx the parse tree + */ + void enterA_expr_unary_not(PostgreSqlParser.A_expr_unary_notContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_unary_not}. + * @param ctx the parse tree + */ + void exitA_expr_unary_not(PostgreSqlParser.A_expr_unary_notContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_isnull}. + * @param ctx the parse tree + */ + void enterA_expr_isnull(PostgreSqlParser.A_expr_isnullContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_isnull}. + * @param ctx the parse tree + */ + void exitA_expr_isnull(PostgreSqlParser.A_expr_isnullContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_is_not}. + * @param ctx the parse tree + */ + void enterA_expr_is_not(PostgreSqlParser.A_expr_is_notContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_is_not}. + * @param ctx the parse tree + */ + void exitA_expr_is_not(PostgreSqlParser.A_expr_is_notContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_compare}. + * @param ctx the parse tree + */ + void enterA_expr_compare(PostgreSqlParser.A_expr_compareContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_compare}. + * @param ctx the parse tree + */ + void exitA_expr_compare(PostgreSqlParser.A_expr_compareContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_like}. + * @param ctx the parse tree + */ + void enterA_expr_like(PostgreSqlParser.A_expr_likeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_like}. + * @param ctx the parse tree + */ + void exitA_expr_like(PostgreSqlParser.A_expr_likeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_qual_op}. + * @param ctx the parse tree + */ + void enterA_expr_qual_op(PostgreSqlParser.A_expr_qual_opContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_qual_op}. + * @param ctx the parse tree + */ + void exitA_expr_qual_op(PostgreSqlParser.A_expr_qual_opContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_unary_qualop}. + * @param ctx the parse tree + */ + void enterA_expr_unary_qualop(PostgreSqlParser.A_expr_unary_qualopContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_unary_qualop}. + * @param ctx the parse tree + */ + void exitA_expr_unary_qualop(PostgreSqlParser.A_expr_unary_qualopContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_add}. + * @param ctx the parse tree + */ + void enterA_expr_add(PostgreSqlParser.A_expr_addContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_add}. + * @param ctx the parse tree + */ + void exitA_expr_add(PostgreSqlParser.A_expr_addContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_mul}. + * @param ctx the parse tree + */ + void enterA_expr_mul(PostgreSqlParser.A_expr_mulContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_mul}. + * @param ctx the parse tree + */ + void exitA_expr_mul(PostgreSqlParser.A_expr_mulContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_caret}. + * @param ctx the parse tree + */ + void enterA_expr_caret(PostgreSqlParser.A_expr_caretContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_caret}. + * @param ctx the parse tree + */ + void exitA_expr_caret(PostgreSqlParser.A_expr_caretContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_unary_sign}. + * @param ctx the parse tree + */ + void enterA_expr_unary_sign(PostgreSqlParser.A_expr_unary_signContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_unary_sign}. + * @param ctx the parse tree + */ + void exitA_expr_unary_sign(PostgreSqlParser.A_expr_unary_signContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_at_time_zone}. + * @param ctx the parse tree + */ + void enterA_expr_at_time_zone(PostgreSqlParser.A_expr_at_time_zoneContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_at_time_zone}. + * @param ctx the parse tree + */ + void exitA_expr_at_time_zone(PostgreSqlParser.A_expr_at_time_zoneContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_collate}. + * @param ctx the parse tree + */ + void enterA_expr_collate(PostgreSqlParser.A_expr_collateContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_collate}. + * @param ctx the parse tree + */ + void exitA_expr_collate(PostgreSqlParser.A_expr_collateContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#a_expr_typecast}. + * @param ctx the parse tree + */ + void enterA_expr_typecast(PostgreSqlParser.A_expr_typecastContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#a_expr_typecast}. + * @param ctx the parse tree + */ + void exitA_expr_typecast(PostgreSqlParser.A_expr_typecastContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#b_expr}. + * @param ctx the parse tree + */ + void enterB_expr(PostgreSqlParser.B_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#b_expr}. + * @param ctx the parse tree + */ + void exitB_expr(PostgreSqlParser.B_exprContext ctx); + /** + * Enter a parse tree produced by the {@code c_expr_exists} + * labeled alternative in {@link PostgreSqlParser#c_expr}. + * @param ctx the parse tree + */ + void enterC_expr_exists(PostgreSqlParser.C_expr_existsContext ctx); + /** + * Exit a parse tree produced by the {@code c_expr_exists} + * labeled alternative in {@link PostgreSqlParser#c_expr}. + * @param ctx the parse tree + */ + void exitC_expr_exists(PostgreSqlParser.C_expr_existsContext ctx); + /** + * Enter a parse tree produced by the {@code c_expr_expr} + * labeled alternative in {@link PostgreSqlParser#c_expr}. + * @param ctx the parse tree + */ + void enterC_expr_expr(PostgreSqlParser.C_expr_exprContext ctx); + /** + * Exit a parse tree produced by the {@code c_expr_expr} + * labeled alternative in {@link PostgreSqlParser#c_expr}. + * @param ctx the parse tree + */ + void exitC_expr_expr(PostgreSqlParser.C_expr_exprContext ctx); + /** + * Enter a parse tree produced by the {@code c_expr_case} + * labeled alternative in {@link PostgreSqlParser#c_expr}. + * @param ctx the parse tree + */ + void enterC_expr_case(PostgreSqlParser.C_expr_caseContext ctx); + /** + * Exit a parse tree produced by the {@code c_expr_case} + * labeled alternative in {@link PostgreSqlParser#c_expr}. + * @param ctx the parse tree + */ + void exitC_expr_case(PostgreSqlParser.C_expr_caseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_application}. + * @param ctx the parse tree + */ + void enterFunc_application(PostgreSqlParser.Func_applicationContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_application}. + * @param ctx the parse tree + */ + void exitFunc_application(PostgreSqlParser.Func_applicationContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_expr}. + * @param ctx the parse tree + */ + void enterFunc_expr(PostgreSqlParser.Func_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_expr}. + * @param ctx the parse tree + */ + void exitFunc_expr(PostgreSqlParser.Func_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_expr_windowless}. + * @param ctx the parse tree + */ + void enterFunc_expr_windowless(PostgreSqlParser.Func_expr_windowlessContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_expr_windowless}. + * @param ctx the parse tree + */ + void exitFunc_expr_windowless(PostgreSqlParser.Func_expr_windowlessContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_expr_common_subexpr}. + * @param ctx the parse tree + */ + void enterFunc_expr_common_subexpr(PostgreSqlParser.Func_expr_common_subexprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_expr_common_subexpr}. + * @param ctx the parse tree + */ + void exitFunc_expr_common_subexpr(PostgreSqlParser.Func_expr_common_subexprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xml_root_version}. + * @param ctx the parse tree + */ + void enterXml_root_version(PostgreSqlParser.Xml_root_versionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xml_root_version}. + * @param ctx the parse tree + */ + void exitXml_root_version(PostgreSqlParser.Xml_root_versionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_xml_root_standalone}. + * @param ctx the parse tree + */ + void enterOpt_xml_root_standalone(PostgreSqlParser.Opt_xml_root_standaloneContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_xml_root_standalone}. + * @param ctx the parse tree + */ + void exitOpt_xml_root_standalone(PostgreSqlParser.Opt_xml_root_standaloneContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xml_attributes}. + * @param ctx the parse tree + */ + void enterXml_attributes(PostgreSqlParser.Xml_attributesContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xml_attributes}. + * @param ctx the parse tree + */ + void exitXml_attributes(PostgreSqlParser.Xml_attributesContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xml_attribute_list}. + * @param ctx the parse tree + */ + void enterXml_attribute_list(PostgreSqlParser.Xml_attribute_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xml_attribute_list}. + * @param ctx the parse tree + */ + void exitXml_attribute_list(PostgreSqlParser.Xml_attribute_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xml_attribute_el}. + * @param ctx the parse tree + */ + void enterXml_attribute_el(PostgreSqlParser.Xml_attribute_elContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xml_attribute_el}. + * @param ctx the parse tree + */ + void exitXml_attribute_el(PostgreSqlParser.Xml_attribute_elContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#document_or_content}. + * @param ctx the parse tree + */ + void enterDocument_or_content(PostgreSqlParser.Document_or_contentContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#document_or_content}. + * @param ctx the parse tree + */ + void exitDocument_or_content(PostgreSqlParser.Document_or_contentContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xml_whitespace_option}. + * @param ctx the parse tree + */ + void enterXml_whitespace_option(PostgreSqlParser.Xml_whitespace_optionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xml_whitespace_option}. + * @param ctx the parse tree + */ + void exitXml_whitespace_option(PostgreSqlParser.Xml_whitespace_optionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xmlexists_argument}. + * @param ctx the parse tree + */ + void enterXmlexists_argument(PostgreSqlParser.Xmlexists_argumentContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xmlexists_argument}. + * @param ctx the parse tree + */ + void exitXmlexists_argument(PostgreSqlParser.Xmlexists_argumentContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xml_passing_mech}. + * @param ctx the parse tree + */ + void enterXml_passing_mech(PostgreSqlParser.Xml_passing_mechContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xml_passing_mech}. + * @param ctx the parse tree + */ + void exitXml_passing_mech(PostgreSqlParser.Xml_passing_mechContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#within_group_clause}. + * @param ctx the parse tree + */ + void enterWithin_group_clause(PostgreSqlParser.Within_group_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#within_group_clause}. + * @param ctx the parse tree + */ + void exitWithin_group_clause(PostgreSqlParser.Within_group_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#filter_clause}. + * @param ctx the parse tree + */ + void enterFilter_clause(PostgreSqlParser.Filter_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#filter_clause}. + * @param ctx the parse tree + */ + void exitFilter_clause(PostgreSqlParser.Filter_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#window_clause}. + * @param ctx the parse tree + */ + void enterWindow_clause(PostgreSqlParser.Window_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#window_clause}. + * @param ctx the parse tree + */ + void exitWindow_clause(PostgreSqlParser.Window_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#window_definition_list}. + * @param ctx the parse tree + */ + void enterWindow_definition_list(PostgreSqlParser.Window_definition_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#window_definition_list}. + * @param ctx the parse tree + */ + void exitWindow_definition_list(PostgreSqlParser.Window_definition_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#window_definition}. + * @param ctx the parse tree + */ + void enterWindow_definition(PostgreSqlParser.Window_definitionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#window_definition}. + * @param ctx the parse tree + */ + void exitWindow_definition(PostgreSqlParser.Window_definitionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#over_clause}. + * @param ctx the parse tree + */ + void enterOver_clause(PostgreSqlParser.Over_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#over_clause}. + * @param ctx the parse tree + */ + void exitOver_clause(PostgreSqlParser.Over_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#window_specification}. + * @param ctx the parse tree + */ + void enterWindow_specification(PostgreSqlParser.Window_specificationContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#window_specification}. + * @param ctx the parse tree + */ + void exitWindow_specification(PostgreSqlParser.Window_specificationContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_existing_window_name}. + * @param ctx the parse tree + */ + void enterOpt_existing_window_name(PostgreSqlParser.Opt_existing_window_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_existing_window_name}. + * @param ctx the parse tree + */ + void exitOpt_existing_window_name(PostgreSqlParser.Opt_existing_window_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_partition_clause}. + * @param ctx the parse tree + */ + void enterOpt_partition_clause(PostgreSqlParser.Opt_partition_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_partition_clause}. + * @param ctx the parse tree + */ + void exitOpt_partition_clause(PostgreSqlParser.Opt_partition_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_frame_clause}. + * @param ctx the parse tree + */ + void enterOpt_frame_clause(PostgreSqlParser.Opt_frame_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_frame_clause}. + * @param ctx the parse tree + */ + void exitOpt_frame_clause(PostgreSqlParser.Opt_frame_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#frame_extent}. + * @param ctx the parse tree + */ + void enterFrame_extent(PostgreSqlParser.Frame_extentContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#frame_extent}. + * @param ctx the parse tree + */ + void exitFrame_extent(PostgreSqlParser.Frame_extentContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#frame_bound}. + * @param ctx the parse tree + */ + void enterFrame_bound(PostgreSqlParser.Frame_boundContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#frame_bound}. + * @param ctx the parse tree + */ + void exitFrame_bound(PostgreSqlParser.Frame_boundContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_window_exclusion_clause}. + * @param ctx the parse tree + */ + void enterOpt_window_exclusion_clause(PostgreSqlParser.Opt_window_exclusion_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_window_exclusion_clause}. + * @param ctx the parse tree + */ + void exitOpt_window_exclusion_clause(PostgreSqlParser.Opt_window_exclusion_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#row}. + * @param ctx the parse tree + */ + void enterRow(PostgreSqlParser.RowContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#row}. + * @param ctx the parse tree + */ + void exitRow(PostgreSqlParser.RowContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explicit_row}. + * @param ctx the parse tree + */ + void enterExplicit_row(PostgreSqlParser.Explicit_rowContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explicit_row}. + * @param ctx the parse tree + */ + void exitExplicit_row(PostgreSqlParser.Explicit_rowContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#implicit_row}. + * @param ctx the parse tree + */ + void enterImplicit_row(PostgreSqlParser.Implicit_rowContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#implicit_row}. + * @param ctx the parse tree + */ + void exitImplicit_row(PostgreSqlParser.Implicit_rowContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#sub_type}. + * @param ctx the parse tree + */ + void enterSub_type(PostgreSqlParser.Sub_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#sub_type}. + * @param ctx the parse tree + */ + void exitSub_type(PostgreSqlParser.Sub_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#all_op}. + * @param ctx the parse tree + */ + void enterAll_op(PostgreSqlParser.All_opContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#all_op}. + * @param ctx the parse tree + */ + void exitAll_op(PostgreSqlParser.All_opContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#mathop}. + * @param ctx the parse tree + */ + void enterMathop(PostgreSqlParser.MathopContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#mathop}. + * @param ctx the parse tree + */ + void exitMathop(PostgreSqlParser.MathopContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#qual_op}. + * @param ctx the parse tree + */ + void enterQual_op(PostgreSqlParser.Qual_opContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#qual_op}. + * @param ctx the parse tree + */ + void exitQual_op(PostgreSqlParser.Qual_opContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#qual_all_op}. + * @param ctx the parse tree + */ + void enterQual_all_op(PostgreSqlParser.Qual_all_opContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#qual_all_op}. + * @param ctx the parse tree + */ + void exitQual_all_op(PostgreSqlParser.Qual_all_opContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#subquery_Op}. + * @param ctx the parse tree + */ + void enterSubquery_Op(PostgreSqlParser.Subquery_OpContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#subquery_Op}. + * @param ctx the parse tree + */ + void exitSubquery_Op(PostgreSqlParser.Subquery_OpContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#expr_list}. + * @param ctx the parse tree + */ + void enterExpr_list(PostgreSqlParser.Expr_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#expr_list}. + * @param ctx the parse tree + */ + void exitExpr_list(PostgreSqlParser.Expr_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_arg_list}. + * @param ctx the parse tree + */ + void enterFunc_arg_list(PostgreSqlParser.Func_arg_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_arg_list}. + * @param ctx the parse tree + */ + void exitFunc_arg_list(PostgreSqlParser.Func_arg_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_arg_expr}. + * @param ctx the parse tree + */ + void enterFunc_arg_expr(PostgreSqlParser.Func_arg_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_arg_expr}. + * @param ctx the parse tree + */ + void exitFunc_arg_expr(PostgreSqlParser.Func_arg_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#type_list}. + * @param ctx the parse tree + */ + void enterType_list(PostgreSqlParser.Type_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#type_list}. + * @param ctx the parse tree + */ + void exitType_list(PostgreSqlParser.Type_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#array_expr}. + * @param ctx the parse tree + */ + void enterArray_expr(PostgreSqlParser.Array_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#array_expr}. + * @param ctx the parse tree + */ + void exitArray_expr(PostgreSqlParser.Array_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#array_expr_list}. + * @param ctx the parse tree + */ + void enterArray_expr_list(PostgreSqlParser.Array_expr_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#array_expr_list}. + * @param ctx the parse tree + */ + void exitArray_expr_list(PostgreSqlParser.Array_expr_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#extract_list}. + * @param ctx the parse tree + */ + void enterExtract_list(PostgreSqlParser.Extract_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#extract_list}. + * @param ctx the parse tree + */ + void exitExtract_list(PostgreSqlParser.Extract_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#extract_arg}. + * @param ctx the parse tree + */ + void enterExtract_arg(PostgreSqlParser.Extract_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#extract_arg}. + * @param ctx the parse tree + */ + void exitExtract_arg(PostgreSqlParser.Extract_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#unicode_normal_form}. + * @param ctx the parse tree + */ + void enterUnicode_normal_form(PostgreSqlParser.Unicode_normal_formContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#unicode_normal_form}. + * @param ctx the parse tree + */ + void exitUnicode_normal_form(PostgreSqlParser.Unicode_normal_formContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#overlay_list}. + * @param ctx the parse tree + */ + void enterOverlay_list(PostgreSqlParser.Overlay_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#overlay_list}. + * @param ctx the parse tree + */ + void exitOverlay_list(PostgreSqlParser.Overlay_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#position_list}. + * @param ctx the parse tree + */ + void enterPosition_list(PostgreSqlParser.Position_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#position_list}. + * @param ctx the parse tree + */ + void exitPosition_list(PostgreSqlParser.Position_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#substr_list}. + * @param ctx the parse tree + */ + void enterSubstr_list(PostgreSqlParser.Substr_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#substr_list}. + * @param ctx the parse tree + */ + void exitSubstr_list(PostgreSqlParser.Substr_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#trim_list}. + * @param ctx the parse tree + */ + void enterTrim_list(PostgreSqlParser.Trim_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#trim_list}. + * @param ctx the parse tree + */ + void exitTrim_list(PostgreSqlParser.Trim_listContext ctx); + /** + * Enter a parse tree produced by the {@code in_expr_select} + * labeled alternative in {@link PostgreSqlParser#in_expr}. + * @param ctx the parse tree + */ + void enterIn_expr_select(PostgreSqlParser.In_expr_selectContext ctx); + /** + * Exit a parse tree produced by the {@code in_expr_select} + * labeled alternative in {@link PostgreSqlParser#in_expr}. + * @param ctx the parse tree + */ + void exitIn_expr_select(PostgreSqlParser.In_expr_selectContext ctx); + /** + * Enter a parse tree produced by the {@code in_expr_list} + * labeled alternative in {@link PostgreSqlParser#in_expr}. + * @param ctx the parse tree + */ + void enterIn_expr_list(PostgreSqlParser.In_expr_listContext ctx); + /** + * Exit a parse tree produced by the {@code in_expr_list} + * labeled alternative in {@link PostgreSqlParser#in_expr}. + * @param ctx the parse tree + */ + void exitIn_expr_list(PostgreSqlParser.In_expr_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#case_expr}. + * @param ctx the parse tree + */ + void enterCase_expr(PostgreSqlParser.Case_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#case_expr}. + * @param ctx the parse tree + */ + void exitCase_expr(PostgreSqlParser.Case_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#when_clause_list}. + * @param ctx the parse tree + */ + void enterWhen_clause_list(PostgreSqlParser.When_clause_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#when_clause_list}. + * @param ctx the parse tree + */ + void exitWhen_clause_list(PostgreSqlParser.When_clause_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#when_clause}. + * @param ctx the parse tree + */ + void enterWhen_clause(PostgreSqlParser.When_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#when_clause}. + * @param ctx the parse tree + */ + void exitWhen_clause(PostgreSqlParser.When_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#case_default}. + * @param ctx the parse tree + */ + void enterCase_default(PostgreSqlParser.Case_defaultContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#case_default}. + * @param ctx the parse tree + */ + void exitCase_default(PostgreSqlParser.Case_defaultContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#case_arg}. + * @param ctx the parse tree + */ + void enterCase_arg(PostgreSqlParser.Case_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#case_arg}. + * @param ctx the parse tree + */ + void exitCase_arg(PostgreSqlParser.Case_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#columnref}. + * @param ctx the parse tree + */ + void enterColumnref(PostgreSqlParser.ColumnrefContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#columnref}. + * @param ctx the parse tree + */ + void exitColumnref(PostgreSqlParser.ColumnrefContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#indirection_el}. + * @param ctx the parse tree + */ + void enterIndirection_el(PostgreSqlParser.Indirection_elContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#indirection_el}. + * @param ctx the parse tree + */ + void exitIndirection_el(PostgreSqlParser.Indirection_elContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_slice_bound}. + * @param ctx the parse tree + */ + void enterOpt_slice_bound(PostgreSqlParser.Opt_slice_boundContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_slice_bound}. + * @param ctx the parse tree + */ + void exitOpt_slice_bound(PostgreSqlParser.Opt_slice_boundContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#indirection}. + * @param ctx the parse tree + */ + void enterIndirection(PostgreSqlParser.IndirectionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#indirection}. + * @param ctx the parse tree + */ + void exitIndirection(PostgreSqlParser.IndirectionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_indirection}. + * @param ctx the parse tree + */ + void enterOpt_indirection(PostgreSqlParser.Opt_indirectionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_indirection}. + * @param ctx the parse tree + */ + void exitOpt_indirection(PostgreSqlParser.Opt_indirectionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_target_list}. + * @param ctx the parse tree + */ + void enterOpt_target_list(PostgreSqlParser.Opt_target_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_target_list}. + * @param ctx the parse tree + */ + void exitOpt_target_list(PostgreSqlParser.Opt_target_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#target_list}. + * @param ctx the parse tree + */ + void enterTarget_list(PostgreSqlParser.Target_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#target_list}. + * @param ctx the parse tree + */ + void exitTarget_list(PostgreSqlParser.Target_listContext ctx); + /** + * Enter a parse tree produced by the {@code target_label} + * labeled alternative in {@link PostgreSqlParser#target_el}. + * @param ctx the parse tree + */ + void enterTarget_label(PostgreSqlParser.Target_labelContext ctx); + /** + * Exit a parse tree produced by the {@code target_label} + * labeled alternative in {@link PostgreSqlParser#target_el}. + * @param ctx the parse tree + */ + void exitTarget_label(PostgreSqlParser.Target_labelContext ctx); + /** + * Enter a parse tree produced by the {@code target_star} + * labeled alternative in {@link PostgreSqlParser#target_el}. + * @param ctx the parse tree + */ + void enterTarget_star(PostgreSqlParser.Target_starContext ctx); + /** + * Exit a parse tree produced by the {@code target_star} + * labeled alternative in {@link PostgreSqlParser#target_el}. + * @param ctx the parse tree + */ + void exitTarget_star(PostgreSqlParser.Target_starContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#qualified_name_list}. + * @param ctx the parse tree + */ + void enterQualified_name_list(PostgreSqlParser.Qualified_name_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#qualified_name_list}. + * @param ctx the parse tree + */ + void exitQualified_name_list(PostgreSqlParser.Qualified_name_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#qualified_name}. + * @param ctx the parse tree + */ + void enterQualified_name(PostgreSqlParser.Qualified_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#qualified_name}. + * @param ctx the parse tree + */ + void exitQualified_name(PostgreSqlParser.Qualified_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#name_list}. + * @param ctx the parse tree + */ + void enterName_list(PostgreSqlParser.Name_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#name_list}. + * @param ctx the parse tree + */ + void exitName_list(PostgreSqlParser.Name_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#name}. + * @param ctx the parse tree + */ + void enterName(PostgreSqlParser.NameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#name}. + * @param ctx the parse tree + */ + void exitName(PostgreSqlParser.NameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#attr_name}. + * @param ctx the parse tree + */ + void enterAttr_name(PostgreSqlParser.Attr_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#attr_name}. + * @param ctx the parse tree + */ + void exitAttr_name(PostgreSqlParser.Attr_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#file_name}. + * @param ctx the parse tree + */ + void enterFile_name(PostgreSqlParser.File_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#file_name}. + * @param ctx the parse tree + */ + void exitFile_name(PostgreSqlParser.File_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_name}. + * @param ctx the parse tree + */ + void enterFunc_name(PostgreSqlParser.Func_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_name}. + * @param ctx the parse tree + */ + void exitFunc_name(PostgreSqlParser.Func_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#aexprconst}. + * @param ctx the parse tree + */ + void enterAexprconst(PostgreSqlParser.AexprconstContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#aexprconst}. + * @param ctx the parse tree + */ + void exitAexprconst(PostgreSqlParser.AexprconstContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#xconst}. + * @param ctx the parse tree + */ + void enterXconst(PostgreSqlParser.XconstContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#xconst}. + * @param ctx the parse tree + */ + void exitXconst(PostgreSqlParser.XconstContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#bconst}. + * @param ctx the parse tree + */ + void enterBconst(PostgreSqlParser.BconstContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#bconst}. + * @param ctx the parse tree + */ + void exitBconst(PostgreSqlParser.BconstContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#fconst}. + * @param ctx the parse tree + */ + void enterFconst(PostgreSqlParser.FconstContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#fconst}. + * @param ctx the parse tree + */ + void exitFconst(PostgreSqlParser.FconstContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#iconst}. + * @param ctx the parse tree + */ + void enterIconst(PostgreSqlParser.IconstContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#iconst}. + * @param ctx the parse tree + */ + void exitIconst(PostgreSqlParser.IconstContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#sconst}. + * @param ctx the parse tree + */ + void enterSconst(PostgreSqlParser.SconstContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#sconst}. + * @param ctx the parse tree + */ + void exitSconst(PostgreSqlParser.SconstContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#anysconst}. + * @param ctx the parse tree + */ + void enterAnysconst(PostgreSqlParser.AnysconstContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#anysconst}. + * @param ctx the parse tree + */ + void exitAnysconst(PostgreSqlParser.AnysconstContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_uescape}. + * @param ctx the parse tree + */ + void enterOpt_uescape(PostgreSqlParser.Opt_uescapeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_uescape}. + * @param ctx the parse tree + */ + void exitOpt_uescape(PostgreSqlParser.Opt_uescapeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#signediconst}. + * @param ctx the parse tree + */ + void enterSignediconst(PostgreSqlParser.SignediconstContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#signediconst}. + * @param ctx the parse tree + */ + void exitSignediconst(PostgreSqlParser.SignediconstContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#roleid}. + * @param ctx the parse tree + */ + void enterRoleid(PostgreSqlParser.RoleidContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#roleid}. + * @param ctx the parse tree + */ + void exitRoleid(PostgreSqlParser.RoleidContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rolespec}. + * @param ctx the parse tree + */ + void enterRolespec(PostgreSqlParser.RolespecContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rolespec}. + * @param ctx the parse tree + */ + void exitRolespec(PostgreSqlParser.RolespecContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#role_list}. + * @param ctx the parse tree + */ + void enterRole_list(PostgreSqlParser.Role_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#role_list}. + * @param ctx the parse tree + */ + void exitRole_list(PostgreSqlParser.Role_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#colid}. + * @param ctx the parse tree + */ + void enterColid(PostgreSqlParser.ColidContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#colid}. + * @param ctx the parse tree + */ + void exitColid(PostgreSqlParser.ColidContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#table_alias}. + * @param ctx the parse tree + */ + void enterTable_alias(PostgreSqlParser.Table_aliasContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#table_alias}. + * @param ctx the parse tree + */ + void exitTable_alias(PostgreSqlParser.Table_aliasContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#type_function_name}. + * @param ctx the parse tree + */ + void enterType_function_name(PostgreSqlParser.Type_function_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#type_function_name}. + * @param ctx the parse tree + */ + void exitType_function_name(PostgreSqlParser.Type_function_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#nonreservedword}. + * @param ctx the parse tree + */ + void enterNonreservedword(PostgreSqlParser.NonreservedwordContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#nonreservedword}. + * @param ctx the parse tree + */ + void exitNonreservedword(PostgreSqlParser.NonreservedwordContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#collabel}. + * @param ctx the parse tree + */ + void enterCollabel(PostgreSqlParser.CollabelContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#collabel}. + * @param ctx the parse tree + */ + void exitCollabel(PostgreSqlParser.CollabelContext ctx); /** * Enter a parse tree produced by {@link PostgreSqlParser#identifier}. * @param ctx the parse tree @@ -2658,83 +6984,1213 @@ public interface PostgreSqlParserListener extends ParseTreeListener { */ void exitIdentifier(PostgreSqlParser.IdentifierContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#todo_fill_in}. + * Enter a parse tree produced by {@link PostgreSqlParser#plsqlidentifier}. * @param ctx the parse tree */ - void enterTodo_fill_in(PostgreSqlParser.Todo_fill_inContext ctx); + void enterPlsqlidentifier(PostgreSqlParser.PlsqlidentifierContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#todo_fill_in}. + * Exit a parse tree produced by {@link PostgreSqlParser#plsqlidentifier}. * @param ctx the parse tree */ - void exitTodo_fill_in(PostgreSqlParser.Todo_fill_inContext ctx); + void exitPlsqlidentifier(PostgreSqlParser.PlsqlidentifierContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#todo_implement}. + * Enter a parse tree produced by {@link PostgreSqlParser#unreserved_keyword}. * @param ctx the parse tree */ - void enterTodo_implement(PostgreSqlParser.Todo_implementContext ctx); + void enterUnreserved_keyword(PostgreSqlParser.Unreserved_keywordContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#todo_implement}. + * Exit a parse tree produced by {@link PostgreSqlParser#unreserved_keyword}. * @param ctx the parse tree */ - void exitTodo_implement(PostgreSqlParser.Todo_implementContext ctx); + void exitUnreserved_keyword(PostgreSqlParser.Unreserved_keywordContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#correlation_name}. + * Enter a parse tree produced by {@link PostgreSqlParser#col_name_keyword}. * @param ctx the parse tree */ - void enterCorrelation_name(PostgreSqlParser.Correlation_nameContext ctx); + void enterCol_name_keyword(PostgreSqlParser.Col_name_keywordContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#correlation_name}. + * Exit a parse tree produced by {@link PostgreSqlParser#col_name_keyword}. * @param ctx the parse tree */ - void exitCorrelation_name(PostgreSqlParser.Correlation_nameContext ctx); + void exitCol_name_keyword(PostgreSqlParser.Col_name_keywordContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#column_name}. + * Enter a parse tree produced by {@link PostgreSqlParser#type_func_name_keyword}. * @param ctx the parse tree */ - void enterColumn_name(PostgreSqlParser.Column_nameContext ctx); + void enterType_func_name_keyword(PostgreSqlParser.Type_func_name_keywordContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#column_name}. + * Exit a parse tree produced by {@link PostgreSqlParser#type_func_name_keyword}. * @param ctx the parse tree */ - void exitColumn_name(PostgreSqlParser.Column_nameContext ctx); + void exitType_func_name_keyword(PostgreSqlParser.Type_func_name_keywordContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#alias}. + * Enter a parse tree produced by {@link PostgreSqlParser#reserved_keyword}. * @param ctx the parse tree */ - void enterAlias(PostgreSqlParser.AliasContext ctx); + void enterReserved_keyword(PostgreSqlParser.Reserved_keywordContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#alias}. + * Exit a parse tree produced by {@link PostgreSqlParser#reserved_keyword}. * @param ctx the parse tree */ - void exitAlias(PostgreSqlParser.AliasContext ctx); + void exitReserved_keyword(PostgreSqlParser.Reserved_keywordContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#column_alias}. + * Enter a parse tree produced by {@link PostgreSqlParser#builtin_function_name}. * @param ctx the parse tree */ - void enterColumn_alias(PostgreSqlParser.Column_aliasContext ctx); + void enterBuiltin_function_name(PostgreSqlParser.Builtin_function_nameContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#column_alias}. + * Exit a parse tree produced by {@link PostgreSqlParser#builtin_function_name}. * @param ctx the parse tree */ - void exitColumn_alias(PostgreSqlParser.Column_aliasContext ctx); + void exitBuiltin_function_name(PostgreSqlParser.Builtin_function_nameContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#column_definition}. + * Enter a parse tree produced by {@link PostgreSqlParser#pl_function}. * @param ctx the parse tree */ - void enterColumn_definition(PostgreSqlParser.Column_definitionContext ctx); + void enterPl_function(PostgreSqlParser.Pl_functionContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#column_definition}. + * Exit a parse tree produced by {@link PostgreSqlParser#pl_function}. * @param ctx the parse tree */ - void exitColumn_definition(PostgreSqlParser.Column_definitionContext ctx); + void exitPl_function(PostgreSqlParser.Pl_functionContext ctx); /** - * Enter a parse tree produced by {@link PostgreSqlParser#window_name}. + * Enter a parse tree produced by {@link PostgreSqlParser#comp_options}. * @param ctx the parse tree */ - void enterWindow_name(PostgreSqlParser.Window_nameContext ctx); + void enterComp_options(PostgreSqlParser.Comp_optionsContext ctx); /** - * Exit a parse tree produced by {@link PostgreSqlParser#window_name}. + * Exit a parse tree produced by {@link PostgreSqlParser#comp_options}. * @param ctx the parse tree */ - void exitWindow_name(PostgreSqlParser.Window_nameContext ctx); + void exitComp_options(PostgreSqlParser.Comp_optionsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#comp_option}. + * @param ctx the parse tree + */ + void enterComp_option(PostgreSqlParser.Comp_optionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#comp_option}. + * @param ctx the parse tree + */ + void exitComp_option(PostgreSqlParser.Comp_optionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#sharp}. + * @param ctx the parse tree + */ + void enterSharp(PostgreSqlParser.SharpContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#sharp}. + * @param ctx the parse tree + */ + void exitSharp(PostgreSqlParser.SharpContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#option_value}. + * @param ctx the parse tree + */ + void enterOption_value(PostgreSqlParser.Option_valueContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#option_value}. + * @param ctx the parse tree + */ + void exitOption_value(PostgreSqlParser.Option_valueContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_semi}. + * @param ctx the parse tree + */ + void enterOpt_semi(PostgreSqlParser.Opt_semiContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_semi}. + * @param ctx the parse tree + */ + void exitOpt_semi(PostgreSqlParser.Opt_semiContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#pl_block}. + * @param ctx the parse tree + */ + void enterPl_block(PostgreSqlParser.Pl_blockContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#pl_block}. + * @param ctx the parse tree + */ + void exitPl_block(PostgreSqlParser.Pl_blockContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_sect}. + * @param ctx the parse tree + */ + void enterDecl_sect(PostgreSqlParser.Decl_sectContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_sect}. + * @param ctx the parse tree + */ + void exitDecl_sect(PostgreSqlParser.Decl_sectContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_start}. + * @param ctx the parse tree + */ + void enterDecl_start(PostgreSqlParser.Decl_startContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_start}. + * @param ctx the parse tree + */ + void exitDecl_start(PostgreSqlParser.Decl_startContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_stmts}. + * @param ctx the parse tree + */ + void enterDecl_stmts(PostgreSqlParser.Decl_stmtsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_stmts}. + * @param ctx the parse tree + */ + void exitDecl_stmts(PostgreSqlParser.Decl_stmtsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#label_decl}. + * @param ctx the parse tree + */ + void enterLabel_decl(PostgreSqlParser.Label_declContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#label_decl}. + * @param ctx the parse tree + */ + void exitLabel_decl(PostgreSqlParser.Label_declContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_stmt}. + * @param ctx the parse tree + */ + void enterDecl_stmt(PostgreSqlParser.Decl_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_stmt}. + * @param ctx the parse tree + */ + void exitDecl_stmt(PostgreSqlParser.Decl_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_statement}. + * @param ctx the parse tree + */ + void enterDecl_statement(PostgreSqlParser.Decl_statementContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_statement}. + * @param ctx the parse tree + */ + void exitDecl_statement(PostgreSqlParser.Decl_statementContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_scrollable}. + * @param ctx the parse tree + */ + void enterOpt_scrollable(PostgreSqlParser.Opt_scrollableContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_scrollable}. + * @param ctx the parse tree + */ + void exitOpt_scrollable(PostgreSqlParser.Opt_scrollableContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_cursor_query}. + * @param ctx the parse tree + */ + void enterDecl_cursor_query(PostgreSqlParser.Decl_cursor_queryContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_cursor_query}. + * @param ctx the parse tree + */ + void exitDecl_cursor_query(PostgreSqlParser.Decl_cursor_queryContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_cursor_args}. + * @param ctx the parse tree + */ + void enterDecl_cursor_args(PostgreSqlParser.Decl_cursor_argsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_cursor_args}. + * @param ctx the parse tree + */ + void exitDecl_cursor_args(PostgreSqlParser.Decl_cursor_argsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_cursor_arglist}. + * @param ctx the parse tree + */ + void enterDecl_cursor_arglist(PostgreSqlParser.Decl_cursor_arglistContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_cursor_arglist}. + * @param ctx the parse tree + */ + void exitDecl_cursor_arglist(PostgreSqlParser.Decl_cursor_arglistContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_cursor_arg}. + * @param ctx the parse tree + */ + void enterDecl_cursor_arg(PostgreSqlParser.Decl_cursor_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_cursor_arg}. + * @param ctx the parse tree + */ + void exitDecl_cursor_arg(PostgreSqlParser.Decl_cursor_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_is_for}. + * @param ctx the parse tree + */ + void enterDecl_is_for(PostgreSqlParser.Decl_is_forContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_is_for}. + * @param ctx the parse tree + */ + void exitDecl_is_for(PostgreSqlParser.Decl_is_forContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_aliasitem}. + * @param ctx the parse tree + */ + void enterDecl_aliasitem(PostgreSqlParser.Decl_aliasitemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_aliasitem}. + * @param ctx the parse tree + */ + void exitDecl_aliasitem(PostgreSqlParser.Decl_aliasitemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_varname}. + * @param ctx the parse tree + */ + void enterDecl_varname(PostgreSqlParser.Decl_varnameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_varname}. + * @param ctx the parse tree + */ + void exitDecl_varname(PostgreSqlParser.Decl_varnameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_const}. + * @param ctx the parse tree + */ + void enterDecl_const(PostgreSqlParser.Decl_constContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_const}. + * @param ctx the parse tree + */ + void exitDecl_const(PostgreSqlParser.Decl_constContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_datatype}. + * @param ctx the parse tree + */ + void enterDecl_datatype(PostgreSqlParser.Decl_datatypeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_datatype}. + * @param ctx the parse tree + */ + void exitDecl_datatype(PostgreSqlParser.Decl_datatypeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_collate}. + * @param ctx the parse tree + */ + void enterDecl_collate(PostgreSqlParser.Decl_collateContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_collate}. + * @param ctx the parse tree + */ + void exitDecl_collate(PostgreSqlParser.Decl_collateContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_notnull}. + * @param ctx the parse tree + */ + void enterDecl_notnull(PostgreSqlParser.Decl_notnullContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_notnull}. + * @param ctx the parse tree + */ + void exitDecl_notnull(PostgreSqlParser.Decl_notnullContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_defval}. + * @param ctx the parse tree + */ + void enterDecl_defval(PostgreSqlParser.Decl_defvalContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_defval}. + * @param ctx the parse tree + */ + void exitDecl_defval(PostgreSqlParser.Decl_defvalContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#decl_defkey}. + * @param ctx the parse tree + */ + void enterDecl_defkey(PostgreSqlParser.Decl_defkeyContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#decl_defkey}. + * @param ctx the parse tree + */ + void exitDecl_defkey(PostgreSqlParser.Decl_defkeyContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#assign_operator}. + * @param ctx the parse tree + */ + void enterAssign_operator(PostgreSqlParser.Assign_operatorContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#assign_operator}. + * @param ctx the parse tree + */ + void exitAssign_operator(PostgreSqlParser.Assign_operatorContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#proc_sect}. + * @param ctx the parse tree + */ + void enterProc_sect(PostgreSqlParser.Proc_sectContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#proc_sect}. + * @param ctx the parse tree + */ + void exitProc_sect(PostgreSqlParser.Proc_sectContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#proc_stmt}. + * @param ctx the parse tree + */ + void enterProc_stmt(PostgreSqlParser.Proc_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#proc_stmt}. + * @param ctx the parse tree + */ + void exitProc_stmt(PostgreSqlParser.Proc_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_perform}. + * @param ctx the parse tree + */ + void enterStmt_perform(PostgreSqlParser.Stmt_performContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_perform}. + * @param ctx the parse tree + */ + void exitStmt_perform(PostgreSqlParser.Stmt_performContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_call}. + * @param ctx the parse tree + */ + void enterStmt_call(PostgreSqlParser.Stmt_callContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_call}. + * @param ctx the parse tree + */ + void exitStmt_call(PostgreSqlParser.Stmt_callContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_expr_list}. + * @param ctx the parse tree + */ + void enterOpt_expr_list(PostgreSqlParser.Opt_expr_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_expr_list}. + * @param ctx the parse tree + */ + void exitOpt_expr_list(PostgreSqlParser.Opt_expr_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_assign}. + * @param ctx the parse tree + */ + void enterStmt_assign(PostgreSqlParser.Stmt_assignContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_assign}. + * @param ctx the parse tree + */ + void exitStmt_assign(PostgreSqlParser.Stmt_assignContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_getdiag}. + * @param ctx the parse tree + */ + void enterStmt_getdiag(PostgreSqlParser.Stmt_getdiagContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_getdiag}. + * @param ctx the parse tree + */ + void exitStmt_getdiag(PostgreSqlParser.Stmt_getdiagContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#getdiag_area_opt}. + * @param ctx the parse tree + */ + void enterGetdiag_area_opt(PostgreSqlParser.Getdiag_area_optContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#getdiag_area_opt}. + * @param ctx the parse tree + */ + void exitGetdiag_area_opt(PostgreSqlParser.Getdiag_area_optContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#getdiag_list}. + * @param ctx the parse tree + */ + void enterGetdiag_list(PostgreSqlParser.Getdiag_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#getdiag_list}. + * @param ctx the parse tree + */ + void exitGetdiag_list(PostgreSqlParser.Getdiag_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#getdiag_list_item}. + * @param ctx the parse tree + */ + void enterGetdiag_list_item(PostgreSqlParser.Getdiag_list_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#getdiag_list_item}. + * @param ctx the parse tree + */ + void exitGetdiag_list_item(PostgreSqlParser.Getdiag_list_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#getdiag_item}. + * @param ctx the parse tree + */ + void enterGetdiag_item(PostgreSqlParser.Getdiag_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#getdiag_item}. + * @param ctx the parse tree + */ + void exitGetdiag_item(PostgreSqlParser.Getdiag_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#getdiag_target}. + * @param ctx the parse tree + */ + void enterGetdiag_target(PostgreSqlParser.Getdiag_targetContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#getdiag_target}. + * @param ctx the parse tree + */ + void exitGetdiag_target(PostgreSqlParser.Getdiag_targetContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#assign_var}. + * @param ctx the parse tree + */ + void enterAssign_var(PostgreSqlParser.Assign_varContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#assign_var}. + * @param ctx the parse tree + */ + void exitAssign_var(PostgreSqlParser.Assign_varContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_if}. + * @param ctx the parse tree + */ + void enterStmt_if(PostgreSqlParser.Stmt_ifContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_if}. + * @param ctx the parse tree + */ + void exitStmt_if(PostgreSqlParser.Stmt_ifContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_elsifs}. + * @param ctx the parse tree + */ + void enterStmt_elsifs(PostgreSqlParser.Stmt_elsifsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_elsifs}. + * @param ctx the parse tree + */ + void exitStmt_elsifs(PostgreSqlParser.Stmt_elsifsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_else}. + * @param ctx the parse tree + */ + void enterStmt_else(PostgreSqlParser.Stmt_elseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_else}. + * @param ctx the parse tree + */ + void exitStmt_else(PostgreSqlParser.Stmt_elseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_case}. + * @param ctx the parse tree + */ + void enterStmt_case(PostgreSqlParser.Stmt_caseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_case}. + * @param ctx the parse tree + */ + void exitStmt_case(PostgreSqlParser.Stmt_caseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_expr_until_when}. + * @param ctx the parse tree + */ + void enterOpt_expr_until_when(PostgreSqlParser.Opt_expr_until_whenContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_expr_until_when}. + * @param ctx the parse tree + */ + void exitOpt_expr_until_when(PostgreSqlParser.Opt_expr_until_whenContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#case_when_list}. + * @param ctx the parse tree + */ + void enterCase_when_list(PostgreSqlParser.Case_when_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#case_when_list}. + * @param ctx the parse tree + */ + void exitCase_when_list(PostgreSqlParser.Case_when_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#case_when}. + * @param ctx the parse tree + */ + void enterCase_when(PostgreSqlParser.Case_whenContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#case_when}. + * @param ctx the parse tree + */ + void exitCase_when(PostgreSqlParser.Case_whenContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_case_else}. + * @param ctx the parse tree + */ + void enterOpt_case_else(PostgreSqlParser.Opt_case_elseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_case_else}. + * @param ctx the parse tree + */ + void exitOpt_case_else(PostgreSqlParser.Opt_case_elseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_loop}. + * @param ctx the parse tree + */ + void enterStmt_loop(PostgreSqlParser.Stmt_loopContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_loop}. + * @param ctx the parse tree + */ + void exitStmt_loop(PostgreSqlParser.Stmt_loopContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_while}. + * @param ctx the parse tree + */ + void enterStmt_while(PostgreSqlParser.Stmt_whileContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_while}. + * @param ctx the parse tree + */ + void exitStmt_while(PostgreSqlParser.Stmt_whileContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_for}. + * @param ctx the parse tree + */ + void enterStmt_for(PostgreSqlParser.Stmt_forContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_for}. + * @param ctx the parse tree + */ + void exitStmt_for(PostgreSqlParser.Stmt_forContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#for_control}. + * @param ctx the parse tree + */ + void enterFor_control(PostgreSqlParser.For_controlContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#for_control}. + * @param ctx the parse tree + */ + void exitFor_control(PostgreSqlParser.For_controlContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_for_using_expression}. + * @param ctx the parse tree + */ + void enterOpt_for_using_expression(PostgreSqlParser.Opt_for_using_expressionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_for_using_expression}. + * @param ctx the parse tree + */ + void exitOpt_for_using_expression(PostgreSqlParser.Opt_for_using_expressionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_cursor_parameters}. + * @param ctx the parse tree + */ + void enterOpt_cursor_parameters(PostgreSqlParser.Opt_cursor_parametersContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_cursor_parameters}. + * @param ctx the parse tree + */ + void exitOpt_cursor_parameters(PostgreSqlParser.Opt_cursor_parametersContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_reverse}. + * @param ctx the parse tree + */ + void enterOpt_reverse(PostgreSqlParser.Opt_reverseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_reverse}. + * @param ctx the parse tree + */ + void exitOpt_reverse(PostgreSqlParser.Opt_reverseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_by_expression}. + * @param ctx the parse tree + */ + void enterOpt_by_expression(PostgreSqlParser.Opt_by_expressionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_by_expression}. + * @param ctx the parse tree + */ + void exitOpt_by_expression(PostgreSqlParser.Opt_by_expressionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#for_variable}. + * @param ctx the parse tree + */ + void enterFor_variable(PostgreSqlParser.For_variableContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#for_variable}. + * @param ctx the parse tree + */ + void exitFor_variable(PostgreSqlParser.For_variableContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_foreach_a}. + * @param ctx the parse tree + */ + void enterStmt_foreach_a(PostgreSqlParser.Stmt_foreach_aContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_foreach_a}. + * @param ctx the parse tree + */ + void exitStmt_foreach_a(PostgreSqlParser.Stmt_foreach_aContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#foreach_slice}. + * @param ctx the parse tree + */ + void enterForeach_slice(PostgreSqlParser.Foreach_sliceContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#foreach_slice}. + * @param ctx the parse tree + */ + void exitForeach_slice(PostgreSqlParser.Foreach_sliceContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_exit}. + * @param ctx the parse tree + */ + void enterStmt_exit(PostgreSqlParser.Stmt_exitContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_exit}. + * @param ctx the parse tree + */ + void exitStmt_exit(PostgreSqlParser.Stmt_exitContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#exit_type}. + * @param ctx the parse tree + */ + void enterExit_type(PostgreSqlParser.Exit_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#exit_type}. + * @param ctx the parse tree + */ + void exitExit_type(PostgreSqlParser.Exit_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_return}. + * @param ctx the parse tree + */ + void enterStmt_return(PostgreSqlParser.Stmt_returnContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_return}. + * @param ctx the parse tree + */ + void exitStmt_return(PostgreSqlParser.Stmt_returnContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_return_result}. + * @param ctx the parse tree + */ + void enterOpt_return_result(PostgreSqlParser.Opt_return_resultContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_return_result}. + * @param ctx the parse tree + */ + void exitOpt_return_result(PostgreSqlParser.Opt_return_resultContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_raise}. + * @param ctx the parse tree + */ + void enterStmt_raise(PostgreSqlParser.Stmt_raiseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_raise}. + * @param ctx the parse tree + */ + void exitStmt_raise(PostgreSqlParser.Stmt_raiseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_stmt_raise_level}. + * @param ctx the parse tree + */ + void enterOpt_stmt_raise_level(PostgreSqlParser.Opt_stmt_raise_levelContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_stmt_raise_level}. + * @param ctx the parse tree + */ + void exitOpt_stmt_raise_level(PostgreSqlParser.Opt_stmt_raise_levelContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_raise_list}. + * @param ctx the parse tree + */ + void enterOpt_raise_list(PostgreSqlParser.Opt_raise_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_raise_list}. + * @param ctx the parse tree + */ + void exitOpt_raise_list(PostgreSqlParser.Opt_raise_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_raise_using}. + * @param ctx the parse tree + */ + void enterOpt_raise_using(PostgreSqlParser.Opt_raise_usingContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_raise_using}. + * @param ctx the parse tree + */ + void exitOpt_raise_using(PostgreSqlParser.Opt_raise_usingContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_raise_using_elem}. + * @param ctx the parse tree + */ + void enterOpt_raise_using_elem(PostgreSqlParser.Opt_raise_using_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_raise_using_elem}. + * @param ctx the parse tree + */ + void exitOpt_raise_using_elem(PostgreSqlParser.Opt_raise_using_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_raise_using_elem_list}. + * @param ctx the parse tree + */ + void enterOpt_raise_using_elem_list(PostgreSqlParser.Opt_raise_using_elem_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_raise_using_elem_list}. + * @param ctx the parse tree + */ + void exitOpt_raise_using_elem_list(PostgreSqlParser.Opt_raise_using_elem_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_assert}. + * @param ctx the parse tree + */ + void enterStmt_assert(PostgreSqlParser.Stmt_assertContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_assert}. + * @param ctx the parse tree + */ + void exitStmt_assert(PostgreSqlParser.Stmt_assertContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_stmt_assert_message}. + * @param ctx the parse tree + */ + void enterOpt_stmt_assert_message(PostgreSqlParser.Opt_stmt_assert_messageContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_stmt_assert_message}. + * @param ctx the parse tree + */ + void exitOpt_stmt_assert_message(PostgreSqlParser.Opt_stmt_assert_messageContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#loop_body}. + * @param ctx the parse tree + */ + void enterLoop_body(PostgreSqlParser.Loop_bodyContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#loop_body}. + * @param ctx the parse tree + */ + void exitLoop_body(PostgreSqlParser.Loop_bodyContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_execsql}. + * @param ctx the parse tree + */ + void enterStmt_execsql(PostgreSqlParser.Stmt_execsqlContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_execsql}. + * @param ctx the parse tree + */ + void exitStmt_execsql(PostgreSqlParser.Stmt_execsqlContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_dynexecute}. + * @param ctx the parse tree + */ + void enterStmt_dynexecute(PostgreSqlParser.Stmt_dynexecuteContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_dynexecute}. + * @param ctx the parse tree + */ + void exitStmt_dynexecute(PostgreSqlParser.Stmt_dynexecuteContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_execute_using}. + * @param ctx the parse tree + */ + void enterOpt_execute_using(PostgreSqlParser.Opt_execute_usingContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_execute_using}. + * @param ctx the parse tree + */ + void exitOpt_execute_using(PostgreSqlParser.Opt_execute_usingContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_execute_using_list}. + * @param ctx the parse tree + */ + void enterOpt_execute_using_list(PostgreSqlParser.Opt_execute_using_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_execute_using_list}. + * @param ctx the parse tree + */ + void exitOpt_execute_using_list(PostgreSqlParser.Opt_execute_using_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_execute_into}. + * @param ctx the parse tree + */ + void enterOpt_execute_into(PostgreSqlParser.Opt_execute_intoContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_execute_into}. + * @param ctx the parse tree + */ + void exitOpt_execute_into(PostgreSqlParser.Opt_execute_intoContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_open}. + * @param ctx the parse tree + */ + void enterStmt_open(PostgreSqlParser.Stmt_openContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_open}. + * @param ctx the parse tree + */ + void exitStmt_open(PostgreSqlParser.Stmt_openContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_open_bound_list_item}. + * @param ctx the parse tree + */ + void enterOpt_open_bound_list_item(PostgreSqlParser.Opt_open_bound_list_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_open_bound_list_item}. + * @param ctx the parse tree + */ + void exitOpt_open_bound_list_item(PostgreSqlParser.Opt_open_bound_list_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_open_bound_list}. + * @param ctx the parse tree + */ + void enterOpt_open_bound_list(PostgreSqlParser.Opt_open_bound_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_open_bound_list}. + * @param ctx the parse tree + */ + void exitOpt_open_bound_list(PostgreSqlParser.Opt_open_bound_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_open_using}. + * @param ctx the parse tree + */ + void enterOpt_open_using(PostgreSqlParser.Opt_open_usingContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_open_using}. + * @param ctx the parse tree + */ + void exitOpt_open_using(PostgreSqlParser.Opt_open_usingContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_scroll_option}. + * @param ctx the parse tree + */ + void enterOpt_scroll_option(PostgreSqlParser.Opt_scroll_optionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_scroll_option}. + * @param ctx the parse tree + */ + void exitOpt_scroll_option(PostgreSqlParser.Opt_scroll_optionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_scroll_option_no}. + * @param ctx the parse tree + */ + void enterOpt_scroll_option_no(PostgreSqlParser.Opt_scroll_option_noContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_scroll_option_no}. + * @param ctx the parse tree + */ + void exitOpt_scroll_option_no(PostgreSqlParser.Opt_scroll_option_noContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_fetch}. + * @param ctx the parse tree + */ + void enterStmt_fetch(PostgreSqlParser.Stmt_fetchContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_fetch}. + * @param ctx the parse tree + */ + void exitStmt_fetch(PostgreSqlParser.Stmt_fetchContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#into_target}. + * @param ctx the parse tree + */ + void enterInto_target(PostgreSqlParser.Into_targetContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#into_target}. + * @param ctx the parse tree + */ + void exitInto_target(PostgreSqlParser.Into_targetContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_cursor_from}. + * @param ctx the parse tree + */ + void enterOpt_cursor_from(PostgreSqlParser.Opt_cursor_fromContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_cursor_from}. + * @param ctx the parse tree + */ + void exitOpt_cursor_from(PostgreSqlParser.Opt_cursor_fromContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_fetch_direction}. + * @param ctx the parse tree + */ + void enterOpt_fetch_direction(PostgreSqlParser.Opt_fetch_directionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_fetch_direction}. + * @param ctx the parse tree + */ + void exitOpt_fetch_direction(PostgreSqlParser.Opt_fetch_directionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_move}. + * @param ctx the parse tree + */ + void enterStmt_move(PostgreSqlParser.Stmt_moveContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_move}. + * @param ctx the parse tree + */ + void exitStmt_move(PostgreSqlParser.Stmt_moveContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_close}. + * @param ctx the parse tree + */ + void enterStmt_close(PostgreSqlParser.Stmt_closeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_close}. + * @param ctx the parse tree + */ + void exitStmt_close(PostgreSqlParser.Stmt_closeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_null}. + * @param ctx the parse tree + */ + void enterStmt_null(PostgreSqlParser.Stmt_nullContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_null}. + * @param ctx the parse tree + */ + void exitStmt_null(PostgreSqlParser.Stmt_nullContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_commit}. + * @param ctx the parse tree + */ + void enterStmt_commit(PostgreSqlParser.Stmt_commitContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_commit}. + * @param ctx the parse tree + */ + void exitStmt_commit(PostgreSqlParser.Stmt_commitContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_rollback}. + * @param ctx the parse tree + */ + void enterStmt_rollback(PostgreSqlParser.Stmt_rollbackContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_rollback}. + * @param ctx the parse tree + */ + void exitStmt_rollback(PostgreSqlParser.Stmt_rollbackContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#plsql_opt_transaction_chain}. + * @param ctx the parse tree + */ + void enterPlsql_opt_transaction_chain(PostgreSqlParser.Plsql_opt_transaction_chainContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#plsql_opt_transaction_chain}. + * @param ctx the parse tree + */ + void exitPlsql_opt_transaction_chain(PostgreSqlParser.Plsql_opt_transaction_chainContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt_set}. + * @param ctx the parse tree + */ + void enterStmt_set(PostgreSqlParser.Stmt_setContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt_set}. + * @param ctx the parse tree + */ + void exitStmt_set(PostgreSqlParser.Stmt_setContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#cursor_variable}. + * @param ctx the parse tree + */ + void enterCursor_variable(PostgreSqlParser.Cursor_variableContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#cursor_variable}. + * @param ctx the parse tree + */ + void exitCursor_variable(PostgreSqlParser.Cursor_variableContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#exception_sect}. + * @param ctx the parse tree + */ + void enterException_sect(PostgreSqlParser.Exception_sectContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#exception_sect}. + * @param ctx the parse tree + */ + void exitException_sect(PostgreSqlParser.Exception_sectContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#proc_exceptions}. + * @param ctx the parse tree + */ + void enterProc_exceptions(PostgreSqlParser.Proc_exceptionsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#proc_exceptions}. + * @param ctx the parse tree + */ + void exitProc_exceptions(PostgreSqlParser.Proc_exceptionsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#proc_exception}. + * @param ctx the parse tree + */ + void enterProc_exception(PostgreSqlParser.Proc_exceptionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#proc_exception}. + * @param ctx the parse tree + */ + void exitProc_exception(PostgreSqlParser.Proc_exceptionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#proc_conditions}. + * @param ctx the parse tree + */ + void enterProc_conditions(PostgreSqlParser.Proc_conditionsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#proc_conditions}. + * @param ctx the parse tree + */ + void exitProc_conditions(PostgreSqlParser.Proc_conditionsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#proc_condition}. + * @param ctx the parse tree + */ + void enterProc_condition(PostgreSqlParser.Proc_conditionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#proc_condition}. + * @param ctx the parse tree + */ + void exitProc_condition(PostgreSqlParser.Proc_conditionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_block_label}. + * @param ctx the parse tree + */ + void enterOpt_block_label(PostgreSqlParser.Opt_block_labelContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_block_label}. + * @param ctx the parse tree + */ + void exitOpt_block_label(PostgreSqlParser.Opt_block_labelContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_loop_label}. + * @param ctx the parse tree + */ + void enterOpt_loop_label(PostgreSqlParser.Opt_loop_labelContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_loop_label}. + * @param ctx the parse tree + */ + void exitOpt_loop_label(PostgreSqlParser.Opt_loop_labelContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_label}. + * @param ctx the parse tree + */ + void enterOpt_label(PostgreSqlParser.Opt_labelContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_label}. + * @param ctx the parse tree + */ + void exitOpt_label(PostgreSqlParser.Opt_labelContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_exitcond}. + * @param ctx the parse tree + */ + void enterOpt_exitcond(PostgreSqlParser.Opt_exitcondContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_exitcond}. + * @param ctx the parse tree + */ + void exitOpt_exitcond(PostgreSqlParser.Opt_exitcondContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#any_identifier}. + * @param ctx the parse tree + */ + void enterAny_identifier(PostgreSqlParser.Any_identifierContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#any_identifier}. + * @param ctx the parse tree + */ + void exitAny_identifier(PostgreSqlParser.Any_identifierContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#plsql_unreserved_keyword}. + * @param ctx the parse tree + */ + void enterPlsql_unreserved_keyword(PostgreSqlParser.Plsql_unreserved_keywordContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#plsql_unreserved_keyword}. + * @param ctx the parse tree + */ + void exitPlsql_unreserved_keyword(PostgreSqlParser.Plsql_unreserved_keywordContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#sql_expression}. + * @param ctx the parse tree + */ + void enterSql_expression(PostgreSqlParser.Sql_expressionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#sql_expression}. + * @param ctx the parse tree + */ + void exitSql_expression(PostgreSqlParser.Sql_expressionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#expr_until_then}. + * @param ctx the parse tree + */ + void enterExpr_until_then(PostgreSqlParser.Expr_until_thenContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#expr_until_then}. + * @param ctx the parse tree + */ + void exitExpr_until_then(PostgreSqlParser.Expr_until_thenContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#expr_until_semi}. + * @param ctx the parse tree + */ + void enterExpr_until_semi(PostgreSqlParser.Expr_until_semiContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#expr_until_semi}. + * @param ctx the parse tree + */ + void exitExpr_until_semi(PostgreSqlParser.Expr_until_semiContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#expr_until_rightbracket}. + * @param ctx the parse tree + */ + void enterExpr_until_rightbracket(PostgreSqlParser.Expr_until_rightbracketContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#expr_until_rightbracket}. + * @param ctx the parse tree + */ + void exitExpr_until_rightbracket(PostgreSqlParser.Expr_until_rightbracketContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#expr_until_loop}. + * @param ctx the parse tree + */ + void enterExpr_until_loop(PostgreSqlParser.Expr_until_loopContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#expr_until_loop}. + * @param ctx the parse tree + */ + void exitExpr_until_loop(PostgreSqlParser.Expr_until_loopContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#make_execsql_stmt}. + * @param ctx the parse tree + */ + void enterMake_execsql_stmt(PostgreSqlParser.Make_execsql_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#make_execsql_stmt}. + * @param ctx the parse tree + */ + void exitMake_execsql_stmt(PostgreSqlParser.Make_execsql_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#opt_returning_clause_into}. + * @param ctx the parse tree + */ + void enterOpt_returning_clause_into(PostgreSqlParser.Opt_returning_clause_intoContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#opt_returning_clause_into}. + * @param ctx the parse tree + */ + void exitOpt_returning_clause_into(PostgreSqlParser.Opt_returning_clause_intoContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#parameter}. + * @param ctx the parse tree + */ + void enterParameter(PostgreSqlParser.ParameterContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#parameter}. + * @param ctx the parse tree + */ + void exitParameter(PostgreSqlParser.ParameterContext ctx); } \ No newline at end of file diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokens.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokens.java index cc9d50ffa..083714bc5 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokens.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokens.java @@ -37,16 +37,16 @@ import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.Sem import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.SemanticTokensDataProvider; import org.springframework.ide.vscode.parser.postgresql.PostgreSqlLexer; import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser; -import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.Data_typeContext; +import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.Attr_nameContext; import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.Func_nameContext; -import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.IdentifierContext; import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.ParameterContext; +import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser.TypenameContext; import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParserBaseListener; public class PostgreSqlSemanticTokens implements SemanticTokensDataProvider { private static List TOKEN_TYPES = List.of("keyword", "type", "string", "number", "operator", - "variable", "regexp", "comment", "parameter", "method"); + "variable", "comment", "parameter", "method"); private Optional optSpelTokens; private Optional> parseErrorHandler; @@ -90,24 +90,23 @@ public class PostgreSqlSemanticTokens implements SemanticTokensDataProvider { private void processTerminalNode(TerminalNode node) { Token token = node.getSymbol(); int type = token.getType(); - if (type >= PostgreSqlLexer.A_ && type <= PostgreSqlLexer.OWNED) { + if (type >= PostgreSqlLexer.ALL && type <= PostgreSqlLexer.TOP) { semantics.put(token, "keyword"); - } else if (type >= PostgreSqlLexer.ABSTIME && type <= PostgreSqlLexer.XML) { - semantics.put(token, "type"); - } else if ((type >= PostgreSqlLexer.AMP && type <= PostgreSqlLexer.SEMI) + } else if (type >= PostgreSqlLexer.ABS && type <= PostgreSqlLexer.TO_NUMBER) { + semantics.put(token, "method"); + } else if ((type >= PostgreSqlLexer.Dollar && type <= PostgreSqlLexer.Operator) || (type >= PostgreSqlLexer.COMMA && type <= PostgreSqlLexer.CLOSE_BRACKET) || type == PostgreSqlLexer.DOT) { semantics.put(token, "operator"); - } else if (type == PostgreSqlLexer.REGEX_STRING) { - semantics.put(token, "regexp"); - } else if (type >= PostgreSqlLexer.SINGLEQ_STRING_LITERAL && type <= PostgreSqlLexer.DOUBLEQ_STRING_LITERAL) { + } else if (type >= PostgreSqlLexer.StringConstant && type <= PostgreSqlLexer.BeginDollarStringConstant) { semantics.put(token, "string"); - } else if ((type >= PostgreSqlLexer.NUMERIC_LITERAL && type <= PostgreSqlLexer.HEX_INTEGER_LITERAL) - || type == PostgreSqlLexer.DOLLAR_DEC || type == PostgreSqlLexer.BIT_STRING) { + } else if ((type >= PostgreSqlLexer.Integral && type <= PostgreSqlLexer.Numeric) + || (type >= PostgreSqlLexer.BinaryStringConstant && type <= PostgreSqlLexer.InvalidUnterminatedHexadecimalStringConstant)) { semantics.put(token, "number"); - } else if (type == PostgreSqlLexer.IDENTIFIER) { + } else if ((type >= PostgreSqlLexer.Identifier && type <= PostgreSqlLexer.InvalidUnterminatedHexadecimalStringConstant) + || type == PostgreSqlLexer.PLSQLIDENTIFIER) { semantics.put(token, "variable"); - } else if (type >= PostgreSqlLexer.BLOCK_COMMENT && type <= PostgreSqlLexer.LINE_COMMENT) { + } else if (type >= PostgreSqlLexer.LineComment && type <= PostgreSqlLexer.UnterminatedBlockComment) { semantics.put(token, "comment"); } else if (type == PostgreSqlLexer.SPEL) { tokens.addAll(JpqlSemanticTokens.computeTokensFromSpelNode(node, initialOffset, optSpelTokens)); @@ -124,40 +123,30 @@ public class PostgreSqlSemanticTokens implements SemanticTokensDataProvider { processTerminalNode(node); } - @Override - public void exitIdentifier(IdentifierContext ctx) { - if (ctx.identifier() != null) { - for (int i = 1; i < ctx.identifier().size(); i++) { - IdentifierContext identifier = ctx.identifier(i); - if (identifier.IDENTIFIER() != null) { - semantics.put(identifier.IDENTIFIER().getSymbol(), "property"); - } - } - } - } - @Override public void exitFunc_name(Func_nameContext funcName) { - if (funcName.identifier() != null && funcName.identifier().IDENTIFIER() != null) { - semantics.put(funcName.identifier().IDENTIFIER().getSymbol(), "method"); - } + AntlrUtils.getAllLeafs(funcName).filter(t -> t.getType() != PostgreSqlLexer.DOT) + .forEach(t -> semantics.put(t, "method")); } @Override - public void exitData_type(Data_typeContext dataType) { - if (dataType.identifier() != null) { - AntlrUtils.getAllLeafs(dataType.identifier()) - .filter(t -> t.getType() == PostgreSqlLexer.IDENTIFIER) + public void exitAttr_name(Attr_nameContext ctx) { + AntlrUtils.getAllLeafs(ctx) + .forEach(t -> semantics.put(t, "proeprty")); + } + + @Override + public void exitTypename(TypenameContext ctx) { + AntlrUtils.getAllLeafs(ctx).filter(t -> t.getType() != PostgreSqlLexer.DOT) .forEach(t -> semantics.put(t, "type")); - } } @Override public void exitParameter(ParameterContext param) { - if (param.identifier() != null) { - AntlrUtils.getAllLeafs(param.identifier()).forEach(t -> semantics.put(t, "parameter")); - } else if (param.INTEGER_LITERAL() != null) { - semantics.put(param.INTEGER_LITERAL().getSymbol(), "parameter"); + if (param.colid() != null) { + AntlrUtils.getAllLeafs(param.colid()).forEach(t -> semantics.put(t, "parameter")); + } else if (param.Integral() != null) { + semantics.put(param.Integral().getSymbol(), "parameter"); } else if (param.reserved_keyword() != null) { AntlrUtils.getAllLeafs(param.reserved_keyword()).forEach(t -> semantics.put(t, "parameter")); } diff --git a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokensTest.java b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokensTest.java index 980456cb7..1f356b669 100644 --- a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokensTest.java +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokensTest.java @@ -58,10 +58,10 @@ public class PostgreSqlSemanticTokensTest { assertThat(tokens.get(26)).isEqualTo(new SemanticTokenData(154, 155, "parameter", new String[0])); // 1 from ?1 assertThat(tokens.get(28)).isEqualTo(new SemanticTokenData(161, 177, "method", new String[0])); // json_path_exists assertThat(tokens.get(33)).isEqualTo(new SemanticTokenData(194, 196, "operator", new String[0])); // :: - assertThat(tokens.get(34)).isEqualTo(new SemanticTokenData(196, 201, "type", new String[0])); // :: + assertThat(tokens.get(34)).isEqualTo(new SemanticTokenData(196, 201, "type", new String[0])); // jsonb assertThat(tokens.get(37)).isEqualTo(new SemanticTokenData(204, 281, "string", new String[0])); // 'strict $.content.**.id ? (@ == "\\' || representation.targetobjectid || \\'")' assertThat(tokens.get(39)).isEqualTo(new SemanticTokenData(282, 284, "operator", new String[0])); // :: - assertThat(tokens.get(40)).isEqualTo(new SemanticTokenData(284, 292, "type", new String[0])); // :: + assertThat(tokens.get(40)).isEqualTo(new SemanticTokenData(284, 292, "type", new String[0])); // jsonpath } @Test @@ -85,7 +85,7 @@ public class PostgreSqlSemanticTokensTest { void semiColonAtEnd() { List tokens = provider.computeTokens(" select count(*) from anecdote where anecdote_id=:anecdote ; ", 0); assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(1, 7, "keyword", new String[0])); // select - assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(8, 13, "keyword", new String[0])); // count + assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(8, 13, "method", new String[0])); // count assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(13, 14, "operator", new String[0])); // ( assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(14, 15, "operator", new String[0])); // * assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(15, 16, "operator", new String[0])); // ) @@ -103,7 +103,7 @@ public class PostgreSqlSemanticTokensTest { @Test void parameterInLimitClause_1() { - List tokens = provider.computeTokens("SELECT * FROM cards ORDER BY random() LIMIT :2", 0); + List tokens = provider.computeTokens("SELECT * FROM cards ORDER BY random() LIMIT ?2", 0); assertThat(tokens.size()).isEqualTo(12); assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0])); @@ -203,7 +203,7 @@ public class PostgreSqlSemanticTokensTest { assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(15, 19, "keyword", new String[0])); assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(20, 32, "variable", new String[0])); assertThat(tokens.get(6)).isEqualTo(new SemanticTokenData(33, 38, "keyword", new String[0])); - assertThat(tokens.get(7)).isEqualTo(new SemanticTokenData(39, 50, "keyword", new String[0])); + assertThat(tokens.get(7)).isEqualTo(new SemanticTokenData(39, 50, "variable", new String[0])); assertThat(tokens.get(8)).isEqualTo(new SemanticTokenData(51, 52, "operator", new String[0])); assertThat(tokens.get(9)).isEqualTo(new SemanticTokenData(53, 54, "operator", new String[0])); assertThat(tokens.get(10)).isEqualTo(new SemanticTokenData(54, 55, "parameter", new String[0])); @@ -285,4 +285,36 @@ public class PostgreSqlSemanticTokensTest { """, 0); assertThat(tokens.size()).isEqualTo(74); } + + @Test + void collate_1() { + List tokens = provider.computeTokens(""" + SELECT DISTINCT test COLLATE "numeric" FROM Test + """, 0); + assertThat(tokens.size()).isEqualTo(7); + assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0])); // SELECT + assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(7, 15, "keyword", new String[0])); // DISTICT + assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(16, 20, "variable", new String[0])); // test + assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(21, 28, "keyword", new String[0])); // COLLATE + assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(29, 38, "variable", new String[0])); // "numeric" + assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(39, 43, "keyword", new String[0])); // FROM + assertThat(tokens.get(6)).isEqualTo(new SemanticTokenData(44, 48, "variable", new String[0])); // Test + } + + @Test + void collate_2() { + List tokens = provider.computeTokens(""" + SELECT a COLLATE "de_DE" < b FROM test1 + """, 0); + assertThat(tokens.size()).isEqualTo(8); + assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0])); // SELECT + assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(7, 8, "variable", new String[0])); // a + assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(9, 16, "keyword", new String[0])); // COLLATE + assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(17, 24, "variable", new String[0])); // "de_DE" + assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(25, 26, "operator", new String[0])); // < + assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(27, 28, "variable", new String[0])); // b + assertThat(tokens.get(6)).isEqualTo(new SemanticTokenData(29, 33, "keyword", new String[0])); // FROM + assertThat(tokens.get(7)).isEqualTo(new SemanticTokenData(34, 39, "variable", new String[0])); // test1 + } + } diff --git a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java index 44b7c957d..a479b1ae6 100644 --- a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryReconcilerTest.java @@ -252,7 +252,7 @@ public class QueryReconcilerTest { String docUri = directory.toPath().resolve("src/main/java/example/demo/OwnerRepository.java").toUri() .toString(); Editor editor = harness.newEditor(LanguageId.JAVA, source, docUri); - editor.assertProblems("ptype|PostgreSQL: no viable alternative at input 'SELECTXptype'"); + editor.assertProblems("SELECTX|PostgreSQL: mismatched input 'SELECTX'"); } @Test